Bitfeld Problem

[aLiEnTxC]

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
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
function Type1Message()
    {
        $message = $this->decodeMessage();
        $hexmessage = bin2hex($message);

        // NTLM Flags
        $tmp = substr($hexmessage, 24, 8);

        $unicode = $this->readbit($tmp, NEOGATE_UNICODE);
        $oem = $this->readbit($tmp, NEOGATE_OEM);
        $target = $this->readbit($tmp, REQUEST_TARGET);
        $sign = $this->readbit($tmp, NEOGATE_SIGN);
        $seal = $this->readbit($tmp, NEOGATE_SEAL);
        $datagram = $this->readbit($tmp, NEOGATE_DATAGRAM_STYLE);
        $lmkey = $this->readbit($tmp, NEOGATE_LAN_MANAGER_KEY);
        $ntlm = $this->readbit($tmp, NEOGATE_NTLM);
        $domain = $this->readbit($tmp, NEOGATE_DOMAIN_SUPPLIED);
        $workstation = $this->readbit($tmp, NEOGATE_WORKSTATION_SUPPLIED);

        $localcall = $this->readbit($tmp, NEOGATE_LOCAL_CALL);
        $always_sign = $this->readbit($tmp, NEOGATE_NEOGATE_ALWAYS_SIGN);
        $typeDomain = $this->readbit($tmp, TARGET_TYPE_DOMAIN);
        $typeServer = $this->readbit($tmp, TARGET_TYPE_SERVER);
        $typeShare = $this->readbit($tmp, TARGET_TYPE_SHARE);
        $ntlm2 = $this->readbit($tmp, NEOGATE_NTLM2_KEY);
        $init_response = $this->readbit($tmp, REQUEST_INIT_RESPONSE);
        $accept_response = $this->readbit($tmp, REQUEST_ACCEPT_RESPONSE);
        $session_key = $this->readbit($tmp, REQUEST_NON_NT_SESSION_KEY);
        $info = $this->readbit($tmp, NEOGATE_TARGET_INFO);
        $Enc128 = $this->readbit($tmp, NEOGATE_128);
        $exchange = $this->readbit($tmp, NEOGATE_KEY_EXCHANGE);
        $Enc56 = $this->readbit($tmp, NEOGATE_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
// 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

[Titus]

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.

[aLiEnTxC]

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

[mrhappiness]

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:

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 />'; 

[aLiEnTxC]

Hi,

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

Ist das so richtig? Stimmt der Zustand nun?

$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 >= 0 ; $i-- )
        {
            if(substr($bin, $i, 1) == "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($binaer, getBit($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

[goth]

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 ... ?!

[aLiEnTxC]

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

[mrhappiness]

Ohne "

[aLiEnTxC]

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 ?

[aLiEnTxC]

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):

$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($binaer, getBit($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

[mrhappiness]

Deine Zahl 0x07b208a2 im Code ist binär 111101100100000100010100010

Also sind die folgenden Bits gesetzt:

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

[aLiEnTxC]

aber wie kann ich das umrechnen?

Würde sich dazu pack bzw unpack anbieten?

Oder ist es damit nicht möglich?

Gruß,
Thomas

[mrhappiness]

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

[aLiEnTxC]

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

$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";
?>

---

[mrhappiness]

Wenn du's mittlerweile als hex hast, musst du pack / unpack trotzdem nicht bemühen:

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)