Wie XOR von zwei hex-Zeichenketten, so dass jedes byte wird XORed getrennt?

Ich haben Beitrag ähnliche Fragen hier für ein paar Tage jetzt, aber es scheint, wie ich wurde nicht gefragt, das richtige zu tun, so entschuldigen Sie mich, wenn ich erschöpft haben Sie mit meinem XOR-Fragen :D.

Auf den Punkt - ich habe zwei hex-Zeichenketten, und ich will XOR diese Zeichenfolgen, so dass jedes byte wird XORed separat (D. H. jedes paar von zahlen ist XORed separat). Und ich möchte das in python und ich möchte in der Lage sein, Zeichenketten unterschiedliche Längen haben. Ich werde tun, ein Beispiel, manuell zu veranschaulichen mein Punkt (ich habe die code-Umgebung, da es mir erlaubt, zu legen Sie in den Räumen wo ich will Sie sein):

Input:
s1 = "48656c6c6f"
s2 = "61736b"

Encoding in binary:
48 65 6c 6c 6f = 01001000 01100101 01101100 01101100 01101111
61 73 6b       = 01100001 01110011 01101011

XORing the strings:
01001000 01100101 01101100 01101100 01101111
                  01100001 01110011 01101011
                  00001101 00011111 00000100

Converting the result to hex:
00001101 00011111 00000100 = 0d 1f 04

Output:
0d1f04

Also, um es zusammenzufassen, ich möchte in der Lage sein, um Eingang zwei hex-strings (diese werden in der Regel ASCII-Zeichen codiert in hex) unterschiedlicher oder gleicher Länge und erhalten Ihre XOR, so dass jedes byte wird XORed getrennt.

  • Warum nicht Zyklus die s2 Schlüssel und für alle Zeichen der s1? Warum gelten Sie es nur für die letzten 3?
InformationsquelleAutor Norsul Ronsul | 2013-07-01
  1. 12

    Verwenden binascii.unhexlify() um Ihre hex-strings zu Binärdaten, dann XOR, dass, gehen Sie zurück zu hex mit binascii.hexlify():

    >>> from binascii import unhexlify, hexlify
>>> s1 = "48656c6c6f"
>>> s2 = "61736b"
>>> hexlify(''.join(chr(ord(c1) ^ ord(c2)) for c1, c2 in zip(unhexlify(s1[-len(s2):]), unhexlify(s2))))
'0d1f04'

    Den tatsächlichen XOR angewendet wird pro byte des dekodierten Daten (mit ord() und chr() zu gehen und von ganzen zahlen).

    Beachten, dass wie in deinem Beispiel, die ich abgeschnitten s1 auf die gleiche Länge wie s2 (ignorieren Zeichen vom start von s1). Kodieren Sie alle von s1 mit einem kürzeren Schlüssel s2 durch Radfahren die bytes:

    >>> from itertools import cycle
>>> hexlify(''.join(chr(ord(c1) ^ ord(c2)) for c1, c2 in zip(unhexlify(s1), cycle(unhexlify(s2)))))
'2916070d1c'

    Du nicht haben Verwendung unhexlify(), aber es ist viel einfacher als Schleifen über s1 und s2 2 Zeichen in einer Zeit und mit int(twocharacters, 16) zu drehen, die in integer-Werte für XOR-Operationen.

    Den Python-3-version der oben genannten ist ein wenig leichter zu machen; verwenden Sie bytes() statt str.join() und Sie können die drop - chr() und ord() Anrufe, die Sie erhalten, Durchlaufen Sie Ganzzahlen direkt:

    >>> from binascii import unhexlify, hexlify
>>> s1 = "48656c6c6f"
>>> s2 = "61736b"
>>> hexlify(bytes(c1 ^ c2 for c1, c2 in zip(unhexlify(s1[-len(s2):]), unhexlify(s2)))) 
b'0d1f04'
>>> from itertools import cycle
>>> hexlify(bytes(c1 ^ c2 for c1, c2 in zip(unhexlify(s1), cycle(unhexlify(s2)))))
b'2916070d1c'
    • Danke für deine Antwort! Was ich nicht verstehe ist dieser Teil: für c1, c2 in zip(unhexlify(s1), Zyklus(unhexlify(s2))))) die Sache ist Die, ich bin neu in python und leicht verwirrt. Ich denke, dass die zip-Funktion hat etwas zu tun mit arrays, aber ich weiß nicht, wie diese Arbeit in Python. Außerdem dachte ich mir zum Schleifen nur einen Zähler, aber hier haben Sie zwei - c1 und c2, die auch mich verwirrt.
    • zip() dauert mehrere input-Sequenzen, und Paare Ihre Elemente. So gibt es Ihnen eine Sequenz von [(s1[0], s2[0]), (s1[1], s2[1]), ...] mit jedem Tupel gebildet, indem Elemente aus jedem Eingabe-Sequenz an den selben index.
    • Denn in diesem Fall zip() hat zwei input-Listen, die jedes output-element ist ein Tupel mit zwei Werten. Die for Schleife entpackt diese in zwei Wert (genau wie Sie tun können, Tupel-Auspacken in der regulären Zuweisung, foo, bar = ('spam', 'eggs') weist foo = 'spam' und bar = 'eggs'.
    • Ich sehe jetzt, aber ich habe ein anderes problem jetzt :D. ich verstehe nicht, was hast du in den zweiten Teil. Was bedeutet es für die Codierung aller von s1? und was bedeutet es, um den Zyklus bytes?
    • Statt nur die Codierung nur 3 Zeichen ('llo' von 'Hello') mit den 3 Zeichen Ihres Schlüssels (ask), verschlüsseln wir alle Hello durch die Wiederverwendung der Schlüssel, beginnend mit der beginnen Sie wieder, wenn Sie das Ende erreichen; H mit a, e mit s, l mit k, mit dem Rad dann wieder zum Anfang und Kodieren l mit a, und o mit s. Die itertools.cycle() Methode ermöglicht uns die Umsetzung Radfahren über s2 mit nur einer Funktion.
    • Jetzt verstehe ich, danke für deine Hilfe!
    • Antwort akzeptiert! Ich bin neu hier, also wusste ich nicht, wie das alles funktioniert 😀

    InformationsquelleAutor Martijn Pieters
  2. 6

    Fand ich eine sehr einfache Lösung:

    def xor_str(a,b):
    result = int(a, 16) ^ int(b, 16) # convert to integers and xor them
    return '{:x}'.format(result)     # convert back to hexadecimal

    Es wird xor der Zeichenkette, bis eine Thema endet

    • Es nervt mich immer, wenn die Menschen nicht verwenden builtin-format. return format(result, 'x').
    InformationsquelleAutor Pini Cheyni
  3. 1

    Ich bin mir nicht sicher, was du genau suchst, aber hoffentlich nützlich sein für Sie.

    >>> def getstr(encoded):
     return "".join([chr(int(i+k, 16))for (i,k) in zip(encoded[0::2], encoded[1::2])])

>>> getstr(s1)
'Hello'

>>> getstr(s2)
'ask'

    Beginnend mit zwei normalen Saiten, können Sie Ihre Ergebnisse etwas wie das zu tun:

    >>> "".join(reversed(["%02X" % (ord(c1) ^ ord(c2)) for c1, c2 in zip(reversed(getstr(s1)),       reversed(getstr(s2)))]))
'0D1F04'
    InformationsquelleAutor Shaddy
Schreibe einen Kommentar