Start · Sprachen · PHP · Referenz · gmp_xor

gmp_xor

Funktion

Berechnet das bitweise XOR zweier GMP-Zahlen und gibt das Ergebnis als neues GMP-Objekt zurück.

seit PHP 4.0.4 Kategorie: math

Signatur

gmp_xor(GMP|int|string $num1, GMP|int|string $num2): GMP

Beschreibung

gmp_xor() führt eine bitweise XOR-Operation (exklusives ODER) auf zwei großen Ganzzahlen (GMP-Objekte, PHP-Integer oder numerische Strings) durch. Beim XOR ist ein Bit im Ergebnis genau dann gesetzt, wenn es in genau einem der beiden Operanden gesetzt ist – aber nicht in beiden gleichzeitig.

Die Funktion ist besonders nützlich für Kryptographie, Hashing, Fehlerkorrektur oder überall dort, wo bitweise Manipulationen auf sehr großen Ganzzahlen erforderlich sind, die den Wertebereich normaler PHP-Integer überschreiten. Normale PHP-Integers sind auf 32 oder 64 Bit begrenzt, während GMP-Zahlen beliebig groß sein können.

Als Eingabe akzeptiert die Funktion GMP-Ressourcen/Objekte (ab PHP 5.6), native PHP-Integer sowie numerische Strings. Das Ergebnis ist stets ein GMP-Objekt, das mit anderen GMP-Funktionen weiterverarbeitet oder mit gmp_strval() in einen lesbaren String umgewandelt werden kann.

Negative Zahlen werden in der Zweierkomplement-Darstellung behandelt, was bei XOR-Operationen mit negativen Operanden zu beachten ist.

Parameter

Name Typ Default Beschreibung
$num1 Pflicht GMP|int|string Der erste Operand der XOR-Operation. Kann ein GMP-Objekt, ein PHP-Integer oder ein numerischer String sein.
$num2 Pflicht GMP|int|string Der zweite Operand der XOR-Operation. Kann ein GMP-Objekt, ein PHP-Integer oder ein numerischer String sein.

Rückgabewert

Typ
GMP
Beschreibung
Gibt ein GMP-Objekt zurück, das das Ergebnis der bitweisen XOR-Operation auf num1 und num2 enthält. Das Ergebnis kann mit gmp_strval(), gmp_intval() oder direkt in arithmetischen GMP-Operationen verwendet werden.

Beispiele

Einfaches bitweises XOR zweier Ganzzahlen

<?php
// 0b1100 XOR 0b1010 = 0b0110 = 6
$a = gmp_init(12); // 1100 in Binär
$b = gmp_init(10); // 1010 in Binär
$result = gmp_xor($a, $b);

echo gmp_strval($result);          // 6
echo PHP_EOL;
echo decbin(gmp_intval($result));  // 110
6 110

XOR mit sehr großen Zahlen (jenseits des int-Bereichs)

<?php
// XOR auf zwei großen Zahlen, die den 64-Bit-Bereich überschreiten
$big1 = gmp_init('123456789012345678901234567890');
$big2 = gmp_init('987654321098765432109876543210');

$xor = gmp_xor($big1, $big2);
echo gmp_strval($xor);
1030700419107837877006203541500

XOR zur einfachen Verschlüsselung (XOR-Cipher)

<?php
// XOR-basierte Verschlüsselung/Entschlüsselung mit GMP
$schluessel = gmp_init('0xDEADBEEF', 16);
$daten      = gmp_init('0xCAFEBABE', 16);

$verschluesselt = gmp_xor($daten, $schluessel);
echo 'Verschlüsselt: ' . gmp_strval($verschluesselt, 16) . PHP_EOL;

// Erneute XOR mit demselben Schlüssel → Original
$entschluesselt = gmp_xor($verschluesselt, $schluessel);
echo 'Entschlüsselt: ' . gmp_strval($entschluesselt, 16) . PHP_EOL;
Verschlüsselt: 14530455 Entschlüsselt: cafebabe

Bit-Differenz zweier Zahlen prüfen

<?php
// Wie viele Bits unterscheiden sich zwischen zwei Zahlen?
$x = gmp_init(0b10110101);
$y = gmp_init(0b11001010);

$diff = gmp_xor($x, $y);
echo 'XOR-Ergebnis: ' . decbin(gmp_intval($diff)) . PHP_EOL;
echo 'Unterschiedliche Bits: ' . gmp_popcount($diff) . PHP_EOL;
XOR-Ergebnis: 1111111 Unterschiedliche Bits: 7

// Wichtig · Fallstricke

Negative Zahlen: Bei negativen Operanden wird die Zweierkomplement-Darstellung verwendet. Das Ergebnis kann negativ sein, wenn beide oder keiner der Operanden negativ ist – dies entspricht dem mathematisch korrekten Verhalten, kann aber unerwartete Ergebnisse liefern, wenn man es nicht beachtet.

Erweiterung erforderlich: Die GMP-Erweiterung (ext/gmp) muss installiert und aktiviert sein. Auf vielen Linux-Systemen ist das Paket php-gmp separat zu installieren. Die Verfügbarkeit kann mit extension_loaded('gmp') geprüft werden.

Performance: Für normale PHP-Integer-Operationen (32/64 Bit) ist der native XOR-Operator (^) deutlich schneller. gmp_xor() lohnt sich erst bei Zahlen, die den nativen Integer-Bereich überschreiten.