Bitfeld Problem

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Bitfeld Problem

    Hallo Forum,

    ich bin gerade dabei eine Klasse für eine NTLM Autentifizierung zu bauen (leider gibt es sowas noch nicht auf php ebene). Und modntlm für Apache kann nicht mit Gruppen umgehen.

    Dazu habe ich mir die Doku von http://davenport.sourceforge.net/ntml.htlm ausgedruck und gut durchgelesen.

    Im allgemeinen bin ich gerade dabei die Type1 Nachricht vom Client zu lesen. In ihr sind von Position X bis Y die NTLM Flags versteckt, die in einem Bitfeld kodiert sind.

    Um eine richtige Antwort auf die gelieferten Daten senden zu können muss ich diese Auswerten.

    Das schaut dann so aus:

    Der Komplette HEX-String
    4e544c4d535350000100000007b208a2040004002e00000006000600280000000501280a0000000f4c4150544f50484f4d45

    Das benötigte Teilstück (was ist dann durch $tmp = substr($hexmessage, 24, 8); ermittele):
    07b208a2

    In der Doku stehen die Definitionen folgendermassen betitelt.

    Flag = 0x00000002 <=> NEOGATE_OEM

    Leider kann ich damit nicht richtig umgehen... Ich verstehe nicht was ich mit den Daten machen soll?

    So wie ich es bis jetzt verstanden habe ist der Wert 0x00000002 die Adresse wo das Bit gesetzt wird. Aber wie kann ich erkennen ob in dem Teilstring 07b208a2 welches Bit gesetzt ist?

    Auf der php.net Seite habe ich unter den Bitoperatoren die folgende Funktion gefunden.

    PHP-Code:
    <?php
    function readbit($val$bit)
        {
           return (
    $val&(0+('0x'.dechex(1<<($bit-1)))))?'1':'0';
        }
    ?>
    Aber wenn ich mit ihr wie hier geschildert Arbeite kommen irgendwie falsche werte raus, die so nicht stimmen können.


    PHP-Quellcode:
    PHP-Code:
    <?php
    function Type1Message()
        {
            
    $message $this->decodeMessage();
            
    $hexmessage bin2hex($message);

            
    // NTLM Flags
            
    $tmp substr($hexmessage248);

            
    $unicode $this->readbit($tmpNEOGATE_UNICODE);
            
    $oem $this->readbit($tmpNEOGATE_OEM);
            
    $target $this->readbit($tmpREQUEST_TARGET);
            
    $sign $this->readbit($tmpNEOGATE_SIGN);
            
    $seal $this->readbit($tmpNEOGATE_SEAL);
            
    $datagram $this->readbit($tmpNEOGATE_DATAGRAM_STYLE);
            
    $lmkey $this->readbit($tmpNEOGATE_LAN_MANAGER_KEY);
            
    $ntlm $this->readbit($tmpNEOGATE_NTLM);
            
    $domain $this->readbit($tmpNEOGATE_DOMAIN_SUPPLIED);
            
    $workstation $this->readbit($tmpNEOGATE_WORKSTATION_SUPPLIED);

            
    $localcall $this->readbit($tmpNEOGATE_LOCAL_CALL);
            
    $always_sign $this->readbit($tmpNEOGATE_NEOGATE_ALWAYS_SIGN);
            
    $typeDomain $this->readbit($tmpTARGET_TYPE_DOMAIN);
            
    $typeServer $this->readbit($tmpTARGET_TYPE_SERVER);
            
    $typeShare $this->readbit($tmpTARGET_TYPE_SHARE);
            
    $ntlm2 $this->readbit($tmpNEOGATE_NTLM2_KEY);
            
    $init_response $this->readbit($tmpREQUEST_INIT_RESPONSE);
            
    $accept_response $this->readbit($tmpREQUEST_ACCEPT_RESPONSE);
            
    $session_key $this->readbit($tmpREQUEST_NON_NT_SESSION_KEY);
            
    $info $this->readbit($tmpNEOGATE_TARGET_INFO);
            
    $Enc128 $this->readbit($tmpNEOGATE_128);
            
    $exchange $this->readbit($tmpNEOGATE_KEY_EXCHANGE);
            
    $Enc56 $this->readbit($tmpNEOGATE_56);

            echo 
    "NEOGATE_UNICODE = ".$unicode."<br>\n";
            echo 
    "NEOGATE_OEM = ".$oem."<br>\n";
            echo 
    "REQUEST_TARGET = ".$target."<br>\n";
            echo 
    "NEOGATE_SIGN = ".$sign."<br>\n";
            echo 
    "NEOGATE_SEAL = ".$seal."<br>\n";
            echo 
    "NEOGATE_DATAGRAM_STYLE = ".$datagram."<br>\n";
            echo 
    "NEOGATE_LAN_MANAGER_KEY = ".$lmkey."<br>\n";
            echo 
    "NEOGATE_NTLM = ".$ntlm."<br>\n";
            echo 
    "NEOGATE_DOMAIN_SUPPLIED = ".$domain."<br>\n";
            echo 
    "NEOGATE_WORKSTATION_SUPPLIED = ".$workstation."<br>\n";
            echo 
    "NEOGATE_LOCAL_CALL = ".$localcall."<br>\n";
            echo 
    "NEOGATE_NEOGATE_ALWAYS_SIGN = ".$always_sign."<br>\n";
            echo 
    "TARGET_TYPE_DOMAIN = ".$typeDomain."<br>\n";
            echo 
    "TARGET_TYPE_SERVER = ".$typeServer."<br>\n";
            echo 
    "TARGET_TYPE_SHARE = ".$typeShare."<br>\n";
            echo 
    "NEOGATE_NTLM2_KEY = ".$ntlm2."<br>\n";
            echo 
    "REQUEST_INIT_RESPONSE = ".$workstation."<br>\n";
            echo 
    "REQUEST_ACCEPT_RESPONSE = ".$accept_response."<br>\n";
            echo 
    "REQUEST_NON_NT_SESSION_KEY = ".$session_key."<br>\n";
            echo 
    "NEOGATE_TARGET_INFO = ".$info."<br>\n";
            echo 
    "NEOGATE_128 = ".$Enc128."<br>\n";
            echo 
    "NEOGATE_KEY_EXCHANGE = ".$exchange."<br>\n";
            echo 
    "NEOGATE_56 = ".$Enc56."<br>\n";
        }
    ?>
    Wobei ich die Konstanden wie folgt definiert habe:


    PHP-Code:
    <?php
    // NTLM Flags
    define("NEOGATE_UNICODE",              "0x00000001");
    define("NEOGATE_OEM",                  "0x00000002");
    define("REQUEST_TARGET",               "0x00000004");
    define("NEOGATE_SIGN",                 "0x00000010");
    define("NEOGATE_SEAL",                 "0x00000020");
    define("NEOGATE_DATAGRAM_STYLE",       "0x00000040");
    define("NEOGATE_LAN_MANAGER_KEY",      "0x00000080");
    define("NEOGATE_NTLM",                 "0x00000200");
    define("NEOGATE_DOMAIN_SUPPLIED",      "0x00001000");
    define("NEOGATE_WORKSTATION_SUPPLIED""0x00002000");
    define("NEOGATE_LOCAL_CALL",           "0x00004000");
    define("NEOGATE_NEOGATE_ALWAYS_SIGN",  "0x00008000");
    define("TARGET_TYPE_DOMAIN",           "0x00010000");
    define("TARGET_TYPE_SERVER",           "0x00020000");
    define("TARGET_TYPE_SHARE",            "0x00040000");
    define("NEOGATE_NTLM2_KEY",            "0x00080000");
    define("REQUEST_INIT_RESPONSE",        "0x00100000");
    define("REQUEST_ACCEPT_RESPONSE",      "0x00200000");
    define("REQUEST_NON_NT_SESSION_KEY",   "0x00400000");
    define("NEOGATE_TARGET_INFO",          "0x00800000");
    define("NEOGATE_128",                  "0x20000000");
    define("NEOGATE_KEY_EXCHANGE",         "0x40000000");
    define("NEOGATE_56",                   "0x80000000");
    ?>
    Kann mir jemand helfen das Problem um zu setzten? Und kennt evtl. jemand eine sehr gut verständliches HowTo? Habe zwar schon mehrere zu dem Thema gelesen aber leider haben diese nur einen Knoten in meinem Hirn hinterlassen *g*

    Gruß,
    Thomas

  • #2
    Du hast vier Probleme:

    1. Der erste Parameter der Funktion sollte ein Integer-Wert sein, Du übergibst aber einen String aus Hexadezimalziffern.
    2. Als zweiter Parameter wird eine Bitnummer erwartet, du übergibts allerdings den Bitwert - und das noch als String.
    3. Die Funktion liefert den Wert mit nur einem Bit UND-maskiert als Hex-String zurück, du erwartest aber einen Boolean-Wert.
    4. Die Funktion arbeitet mit Integerwerten. In NEOGATE_56 ist Bit32 gesetzt. Das Integer-Äguivalent ist also negativ, damit können aber die wenigsten PHP-eigenen Funktionen nicht umgehen. Das müsstest Du also vermutlich extra abbprüfen.
    mein Sport: mein Frühstück: meine Arbeit:

    Sämtliche Code-Schnipsel sind im Allgemeinen nicht getestet und werden ohne Gewähr auf Fehlerfreiheit und Korrektheit gepostet.

    Kommentar


    • #3
      hmm.. gut zu wissen.. danke!

      woher hast du das alles erkannt?

      zu 1:
      also kann ich den wert einfach mit der funktion hexdec umwandeln?

      zu 2:
      verstehe ich nicht ganz :-( was ist der unterschied zwischen einer bitnummer und einem bitwert?

      Also wie erkenne ich was für ein BIT gesetzt sein muss, wenn ich wissen will ob z.b. NEOGATE_128 gesetzt ist? (wie hast du das umgerechtet?)

      zu 3:
      ja genau, aber da kommt doch 0 und 1 raus??

      zu 4:
      was ist ein Integer-Äguivalent?

      Ist es dann überhaupt möglich eine solche funktion zu erstellen?


      Gruß,
      Thomas

      Kommentar


      • #4
        1. z. B.

        2.
        Die Zahl 11 stellst du in Bits so dar: 1011
        Die Bits mit den Nummer 0, 1 und 3 sind also gesetzt (man fängt von rechts an und das nullbasiert)

        Bitnummer => Bitwert:
        Bitnummer 0 = 1 * 2^0 = 1 (Bitwert)
        Bitnummer 1 = 1 * 2^1 = 2 (Bitwert)
        Bitnummer 2 = 0 * 2^2 = 0 (Bitwert) Multiplikation mit 0, da Bit nicht gesetzt
        Bitnummer 3 = 1 * 2^3 = 9 (Bitwert)

        Welches Bit bei NEOGATE_56 gesetzt ist, kriegst du so raus:
        Gesucht: 2^x = NEOGATE_56
        Aufgelöst: x = log(NEOGATE_56) / log(2) = 31

        Der übliche integer-Wertebereich geht von -2^31 bis 2^31 - 1
        Größere oder kleiner Werte werden automatisch in float konvertiert
        Wird allerdings ein int-Wert erwartet, dann ist das Ergebnis negativ, denn 2^31 ist keine gültige int-Zahl, es kommt zu einem Überlauf und PHP fängt vonganz vorne wieder an und ganze vorne ist eben -2^31


        Was du machen könntest:
        Nicht mit dem Hexwert sondern mit dem Bitwert rechnen, z. B. so:
        PHP-Code:
        function hexbin($hex) {
          
        $bin '';
          for(
        $i 0$i strlen($hex); $i++)
            
        $bin .= str_pad(decbin(hexdec($hex{$i})), 4'0'STR_PAD_LEFT);
          return 
        $bin;


        function 
        bit_set($bin$bit) {
          if (
        $bit >= strlen($bin))
            return 
        false;
          if (
        $bit 0)
            return 
        false;
          return 
        $bin{strlen($bin) - $bit 1} == '1';
        }

        $binaer hexbin('07b208a2');
        echo 
        $binaer;
        echo 
        '<br />';
        for (
        $i = -1$i 40$i++)
          echo 
        'Bit '.$i.': '.(int)bit_set($binaer$i).'<br />'
        Ich denke, also bin ich. - Einige sind trotzdem...

        Kommentar


        • #5
          Hi,

          ich bin eben mal wieder an das Problem gegangen...

          Ist das so richtig? Stimmt der Zustand nun?

          PHP-Code:
          $ntlmflags = array (
             
          "NEOGATE_UNICODE"                => "0x00000001",
             
          "NEOGATE_OEM"                    => "0x00000002",
             
          "REQUEST_TARGET"                 => "0x00000004",
             
          "NEOGATE_SIGN"                   => "0x00000010",
             
          "NEOGATE_SEAL"                   => "0x00000020",
             
          "NEOGATE_DATAGRAM_STYLE"         => "0x00000040",
             
          "NEOGATE_LAN_MANAGER_KEY"        => "0x00000080",
             
          "NEOGATE_NTLM"                   => "0x00000200",
             
          "NEOGATE_DOMAIN_SUPPLIED"        => "0x00001000",
             
          "NEOGATE_WORKSTATION_SUPPLIED"   => "0x00002000",
             
          "NEOGATE_LOCAL_CALL"             => "0x00004000",
             
          "NEOGATE_NEOGATE_ALWAYS_SIGN"    => "0x00008000",
             
          "TARGET_TYPE_DOMAIN"             => "0x00010000",
             
          "TARGET_TYPE_SERVER"             => "0x00020000",
             
          "TARGET_TYPE_SHARE"              => "0x00040000",
             
          "NEOGATE_NTLM2_KEY"              => "0x00080000",
             
          "REQUEST_INIT_RESPONSE"          => "0x00100000",
             
          "REQUEST_ACCEPT_RESPONSE"        => "0x00200000",
             
          "REQUEST_NON_NT_SESSION_KEY"     => "0x00400000",
             
          "NEOGATE_TARGET_INFO"            => "0x00800000",
             
          "NEOGATE_128"                    => "0x20000000",
             
          "NEOGATE_KEY_EXCHANGE"           => "0x40000000",
             
          "NEOGATE_56"                     => "0x80000000",
          );

              function 
          hexbin($hex)
              {
                  
          $bin '';
                  for(
          $i 0$i strlen($hex); $i++)
                  
          $bin .= str_pad(decbin(hexdec($hex{$i})), 4'0'STR_PAD_LEFT);
                  return 
          $bin;
              }
              function 
          bit_set($bin$bit) {
                  if (
          $bit >= strlen($bin))
                      return 
          false;
                  if (
          $bit 0)
                      return 
          false;
                  return 
          $bin{strlen($bin) - $bit 1} == '1';
              }
              function 
          getBit($hexWert)
              {
                  
          $bin hexbin($hexWert);

                  for(
          $i strlen($bin); $i >= $i-- )
                  {
                      if(
          substr($bin$i1) == "1" )
                          return 
          strlen($bin)-$i-1;
                  }
                  return 
          false;
              }

                  
          $tmp "07b208a2";

                  
          $binaer hexbin($tmp);

                  echo 
          "Hex = ".$tmp."<br>";
                  echo 
          "Binaer = ".$binaer."<br><hr>";

                  echo 
          "<table border=1>";
                  echo 
          "<tr>\n";
                  echo 
          "<th>Flag</th>";
                  echo 
          "<th>Hex-Wert</th>";
                  echo 
          "<th>Dec-Wert</th>";
                  echo 
          "<th>Bin-Wert</th>";
                  echo 
          "<th>Stelle des Bits</th>";
                  echo 
          "<th>Zustand</th>";
                  echo 
          "</tr>\n";
                  foreach(
          $ntlmflags as $flag => $wert)
                  {
                      echo 
          "<tr>\n";
                      echo 
          "<td>".$flag."</td>";
                      echo 
          "<td>".$wert."</td>";
                      echo 
          "<td>".hexdec($wert)."</td>";
                      echo 
          "<td>".hexbin($wert)."</td>";
                      echo 
          "<td>".getBit($wert)."</td>";
                      echo 
          "<td>".(int)bit_set($binaergetBit($wert))."</td>";
                      echo 
          "</tr>";
                  }
                  echo 
          "</table>"
          Und wie könnte man was verbessern?

          EDIT:

          So ich habe es nochmal mit den Testwert der Doku versucht.

          Also bei dem übermitteltem Hex Wert 0x07320000 sollen diese Flags gesetzt sein.

          neogote_unicode
          neogate_oem
          request_target
          neogate_ntlm
          neogate_domain_supplied
          noegate_workstation_supplied

          Aber mit meiner Funktion sind diese Werte nicht gesetzt!

          Was mache ich falsch?


          Gruß,
          Thomas
          Zuletzt geändert von aLiEnTxC; 21.02.2005, 16:55.

          Kommentar


          • #6
            1. Ich wundere mich das immer wieder Leute denen rudimentäre Grundbegriffe fehlen (hier z.B. Binäre Arithmetik) an solche Projekte wagen ...

            2. Frage ich mich warum Du die $ntlmflags als Strings auslegst ... ist das nicht nahe am Schwachsinn ... ?!
            carpe noctem

            [color=blue]Bitte keine Fragen per EMail ... im Forum haben alle was davon ... und ich beantworte EMail-Fragen von Foren-Mitgliedern in der Regel eh nicht![/color]
            [color=red]Hinweis: Ich bin weder Mitglied noch Angestellter von ebiz-consult! Alles was ich hier von mir gebe tue ich in eigener Verantwortung![/color]

            Kommentar


            • #7
              zu 2. wie kann man es denn in php noch machen??

              Kommentar


              • #8
                Ohne "
                Ich denke, also bin ich. - Einige sind trotzdem...

                Kommentar


                • #9
                  ok... aber was ändert es?

                  Es tut dann immer noch nich...

                  noch zu 1: Irgendwann muss man es ja lernen ;-)

                  Warum nicht in solch einem Projekt ?
                  Zuletzt geändert von aLiEnTxC; 21.02.2005, 17:54.

                  Kommentar


                  • #10
                    Bitfeld Problem die zweite

                    EDIT:
                    nix mit "problem, die zweite" - *zusammenführ*
                    wahsaga



                    Hallo Forum,

                    ich versuche immer noch ein Bitfeld zu analysieren, komme aber irgendwie nicht weiter...

                    Problem:

                    Ich bekomme einen Hexadecimalen String wie z.B.: 0x07320000
                    So nun weiss ich aus einer Doku das z.B. das Flag NEOGATE_UNICODE über 0x00000001 ausgelesen werden kann.

                    Dazu habe ich mal folgenden Code entworfen (kann direkt per copy & paste getestet werden):

                    PHP-Code:
                    $ntlmflags = array (
                       
                    "NEOGATE_UNICODE"                => "0x00000001",
                       
                    "NEOGATE_OEM"                    => "0x00000002",
                       
                    "REQUEST_TARGET"                 => "0x00000004",
                       
                    "NEOGATE_SIGN"                   => "0x00000010",
                       
                    "NEOGATE_SEAL"                   => "0x00000020",
                       
                    "NEOGATE_DATAGRAM_STYLE"         => "0x00000040",
                       
                    "NEOGATE_LAN_MANAGER_KEY"        => "0x00000080",
                       
                    "NEOGATE_NTLM"                   => "0x00000200",
                       
                    "NEOGATE_DOMAIN_SUPPLIED"        => "0x00001000",
                       
                    "NEOGATE_WORKSTATION_SUPPLIED"   => "0x00002000",
                       
                    "NEOGATE_LOCAL_CALL"             => "0x00004000",
                       
                    "NEOGATE_NEOGATE_ALWAYS_SIGN"    => "0x00008000",
                       
                    "TARGET_TYPE_DOMAIN"             => "0x00010000",
                       
                    "TARGET_TYPE_SERVER"             => "0x00020000",
                       
                    "TARGET_TYPE_SHARE"              => "0x00040000",
                       
                    "NEOGATE_NTLM2_KEY"              => "0x00080000",
                       
                    "REQUEST_INIT_RESPONSE"          => "0x00100000",
                       
                    "REQUEST_ACCEPT_RESPONSE"        => "0x00200000",
                       
                    "REQUEST_NON_NT_SESSION_KEY"     => "0x00400000",
                       
                    "NEOGATE_TARGET_INFO"            => "0x00800000",
                       
                    "NEOGATE_128"                    => "0x20000000",
                       
                    "NEOGATE_KEY_EXCHANGE"           => "0x40000000",
                       
                    "NEOGATE_56"                     => "0x80000000",
                    );

                        function 
                    hexbin($hex)
                        {
                            
                    $bin '';
                            for(
                    $i 0$i strlen($hex); $i++)
                            
                    $bin .= str_pad(decbin(hexdec($hex{$i})), 4'0'STR_PAD_LEFT);
                            return 
                    $bin;
                        }
                        function 
                    bit_set($bin$bit) {
                            if (
                    $bit >= strlen($bin))
                                return 
                    false;
                            if (
                    $bit 0)
                                return 
                    false;
                            return 
                    $bin{strlen($bin) - $bit 1} == '1';
                        }
                        function 
                    getBit($hexWert)
                        {
                             return 
                    log(hexdec($hexWert)) / log(2);
                        }

                            
                    $tmp "07b208a2";

                            
                    $binaer hexbin($tmp);

                            echo 
                    "Hex = ".$tmp."<br>";
                            echo 
                    "Binaer = ".$binaer."<br><hr>";

                            echo 
                    "<table border=1>";
                            echo 
                    "<tr>\n";
                            echo 
                    "<th>Flag</th>";
                            echo 
                    "<th>Hex-Wert</th>";
                            echo 
                    "<th>Dec-Wert</th>";
                            echo 
                    "<th>Bin-Wert</th>";
                            echo 
                    "<th>Stelle des Bits</th>";
                            echo 
                    "<th>Zustand</th>";
                            echo 
                    "</tr>\n";
                            foreach(
                    $ntlmflags as $flag => $wert)
                            {
                                echo 
                    "<tr>\n";
                                echo 
                    "<td>".$flag."</td>";
                                echo 
                    "<td>".$wert."</td>";
                                echo 
                    "<td>".hexdec($wert)."</td>";
                                echo 
                    "<td>".hexbin($wert)."</td>";
                                echo 
                    "<td>".getBit($wert)."</td>";
                                echo 
                    "<td>".(int)bit_set($binaergetBit($wert))."</td>";
                                echo 
                    "</tr>";
                            }
                            echo 
                    "</table>"
                    Das Problem ist nur das das so anscheindend nicht richtig ist.

                    Denn laut Doku sollen dann folgende Flags gesetzt sein:

                    Negotiate Unicode (0x00000001)
                    Negotiate OEM (0x00000002)
                    Request Target (0x00000004)
                    Negotiate NTLM (0x00000200)
                    Negotiate Domain Supplied (0x00001000)
                    Negotiate Workstation Supplied (0x00002000)

                    Aber das ist bei mir nicht der fall... vieleicht sieht jemand was ich falsch mache... ich blick´s voll nicht

                    Gruß,
                    Thomas
                    Zuletzt geändert von wahsaga; 28.02.2005, 16:05.

                    Kommentar


                    • #11
                      Deine Zahl 0x07b208a2 im Code ist binär 111101100100000100010100010

                      Also sind die folgenden Bits gesetzt:
                      Code:
                      Bit	Dezimal		Flag
                      1	1		NEOGATE_OEM
                      5	32		NEOGATE_SEAL 
                      7	128		NEOGATE_LAN_MANAGER_KEY
                      [color=red]11	2048		NEOGATE_DUMMY_11[/color]
                      17	131072		TARGET_TYPE_SERVER
                      20	1048576		REQUEST_INIT_RESPONSE
                      21	2097152		REQUEST_ACCEPT_RESPONSE
                      23	8388608		NEOGATE_TARGET_INFO
                      [color=red]24	16777216	NEOGATE_DUMMY_24[/color]
                      [color=red]25	33554432	NEOGATE_DUMMY_25[/color]
                      [color=red]26	67108864	NEOGATE_DUMMY_26[/color]
                      rot = Flags, die du nicht gesetzt hast, brauchst du aber auch nicht unbedingt, s. u.

                      Hast du deine DOku denn auch richtig gelsen?
                      Negotiate Unicode (0x00000001)
                      Request Target (0x00000004)
                      Negotiate NTLM (0x00000200)
                      Negotiate Always Sign (0x00008000)

                      Combining the above gives "0x00008205". This would be physically laid out as "0x05820000" (since it is represented in little-endian byte order).
                      Sieht für mich aus, als müsstest du was umstellen, meinst du nicht auch?

                      Statt 0x07b208a2 musst du also 0xa20807b2 prüfen und statt 0x07320000 solltest du 0x00000732 prüfen

                      Unterschied zwischen Little und Big Endian:
                      - Nieder und Höherwertiges Wort sind vertauscht
                      - Nieder und Höherwertiges Byte dadrin sind auch vertauscht

                      Wenn du die Vertauschung ebenfalls durchführst, hast du wieder Big Endian und deine Prüfroutine funktioniert
                      Zuletzt geändert von mrhappiness; 01.03.2005, 07:57.
                      Ich denke, also bin ich. - Einige sind trotzdem...

                      Kommentar


                      • #12
                        aber wie kann ich das umrechnen?

                        Würde sich dazu pack bzw unpack anbieten?

                        Oder ist es damit nicht möglich?

                        Gruß,
                        Thomas

                        Kommentar


                        • #13
                          Original geschrieben von mrhappiness
                          Statt 0x07b208a2 musst du also 0xa20807b2 prüfen und statt 0x07320000 solltest du 0x00000732 prüfen

                          Unterschied zwischen Little und Big Endian:
                          - Nieder und Höherwertiges Wort sind vertauscht
                          - Nieder und Höherwertiges Byte dadrin sind auch vertauscht

                          Wenn du die Vertauschung ebenfalls durchführst, hast du wieder Big Endian und deine Prüfroutine funktioniert
                          str_replace kann das auf jeden Fall
                          Zuletzt geändert von mrhappiness; 01.03.2005, 11:23.
                          Ich denke, also bin ich. - Einige sind trotzdem...

                          Kommentar


                          • #14
                            hmm.. aber dann muss ich ja die variablen wieder als string behandeln.

                            Ist es nicht besser sie als hex zu definieren?

                            EDIT:


                            Oh sorry.. meinen aktuellen status des codes habe ich noch garnicht gepostet...

                            ... denn dort hab ich es nun anders definiert... aber ok.. ich versuche es mal wieder wie vorher..

                            (hier nochmal mein akueller code, vieleicht ist es mit dem ja besser auszuwerten)
                            PHP-Code:
                            <?php

                            $ntlmflags 
                            = array (
                               
                            "NEOGATE_UNICODE"                => 0x00000001,
                               
                            "NEOGATE_OEM"                    => 0x00000002,
                               
                            "REQUEST_TARGET"                 => 0x00000004,
                               
                            "NEOGATE_SIGN"                   => 0x00000010,
                               
                            "NEOGATE_SEAL"                   => 0x00000020,
                               
                            "NEOGATE_DATAGRAM_STYLE"         => 0x00000040,
                               
                            "NEOGATE_LAN_MANAGER_KEY"        => 0x00000080,
                               
                            "NEOGATE_NTLM"                   => 0x00000200,
                               
                            "NEOGATE_DOMAIN_SUPPLIED"        => 0x00001000,
                               
                            "NEOGATE_WORKSTATION_SUPPLIED"   => 0x00002000,
                               
                            "NEOGATE_LOCAL_CALL"             => 0x00004000,
                               
                            "NEOGATE_NEOGATE_ALWAYS_SIGN"    => 0x00008000,
                               
                            "TARGET_TYPE_DOMAIN"             => 0x00010000,
                               
                            "TARGET_TYPE_SERVER"             => 0x00020000,
                               
                            "TARGET_TYPE_SHARE"              => 0x00040000,
                               
                            "NEOGATE_NTLM2_KEY"              => 0x00080000,
                               
                            "REQUEST_INIT_RESPONSE"          => 0x00100000,
                               
                            "REQUEST_ACCEPT_RESPONSE"        => 0x00200000,
                               
                            "REQUEST_NON_NT_SESSION_KEY"     => 0x00400000,
                               
                            "NEOGATE_TARGET_INFO"            => 0x00800000,
                               
                            "NEOGATE_128"                    => 0x20000000,
                               
                            "NEOGATE_KEY_EXCHANGE"           => 0x40000000,
                               
                            "NEOGATE_56"                     => 0x80000000,
                            );

                                function 
                            getBit($hexWert)
                                {
                                     return 
                            log($hexWert) / log(2);
                                }

                                    
                            $tmp 0x07b208a2;

                                    
                            //$binaer = hexbin($tmp);

                                    
                            echo "Hex = ".sprintf("%X"$tmp)."<br>";
                                    echo 
                            "Binaer = ".sprintf("%b"$tmp)."<br><hr>\n";

                                    echo 
                            "<table border=1>\n";
                                    echo 
                            " <tr>\n";
                                    echo 
                            "  <th>Flag</th>\n";
                                    echo 
                            "  <th>Hex-Wert</th>\n";
                                    echo 
                            "  <th>Dec-Wert</th>\n";
                                    echo 
                            "  <th>Bin-Wert</th>\n";
                                    echo 
                            "  <th>Stelle des Bits</th>\n";
                                    echo 
                            "  <th>Zustand</th>\n";
                                    echo 
                            " </tr>\n";

                                    foreach(
                            $ntlmflags as $flag => $wert)
                                    {
                                        echo 
                            " <tr>\n";
                                        echo 
                            "  <td>".$flag."</td>\n";
                                        echo 
                            "  <td>".sprintf("%X"$wert)."</td>\n";
                                        echo 
                            "  <td>".$wert."</td>\n";
                                        echo 
                            "  <td>".sprintf("%b"$wert)."</td>\n";
                                        echo 
                            "  <td>".getBit($wert)."</td>\n";
                                        echo 
                            "  <td>";
                                        if(
                            $wert $tmp == $wert) echo 1; else echo 0;
                                        echo 
                            "  </td>\n";
                                        echo 
                            " </tr>\n";
                                    }
                                    echo 
                            "</table>\n";
                            ?>

                            Zuletzt geändert von aLiEnTxC; 01.03.2005, 11:33.

                            Kommentar


                            • #15
                              Wenn du's mittlerweile als hex hast, musst du pack / unpack trotzdem nicht bemühen:
                              PHP-Code:
                              function convert_little_endian($original) {
                                  
                              $bytes['hiword']['hibyte'] = ($original 0xff000000) >> 24;
                                  
                              $bytes['hiword']['lobyte'] = ($original 0x00ff0000) >> 16;
                                  
                              $bytes['loword']['hibyte'] = ($original 0x0000ff00) >> 8;
                                  
                              $bytes['loword']['lobyte'] = ($original 0x000000ff);
                                  
                              $original $bytes['hiword']['hibyte'] +
                                      (
                              $bytes['hiword']['lobyte'] << 8) +
                                      (
                              $bytes['loword']['hibyte'] << 16) +
                                      (
                              $bytes['loword']['lobyte'] << 24);
                                  return 
                              $original;

                              (Kannst es natürlich auch mit pack/unpack machen)
                              Ich denke, also bin ich. - Einige sind trotzdem...

                              Kommentar

                              Lädt...
                              X