Comment XOR de deux hex de chaînes, de sorte que chaque octet est XORed séparément?

J'ai été l'affichage des questions similaires ici pour un couple de jours maintenant, mais il me semble que je ne demande pas la bonne chose, donc excusez-moi si j'ai épuisé mon XOR questions :D.

Au point - j'ai deux hex cordes et je veux XOR ces chaînes de telle sorte que chaque octet est XORed séparément (c'est à dire chaque paire de nombres est XORed séparément). Et je veux le faire en python, et je veux être en mesure d'avoir des chaînes de longueurs différentes. Je vais faire un exemple manuellement pour illustrer mon point de vue (j'ai utilisé le code de l'environnement, car il me permet de me mettre dans des espaces où je veux qu'ils soient):

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

Donc, pour résumer, je veux être en mesure à l'entrée deux hex de chaînes de caractères (en général, ces lettres ASCII codé en hexadécimal) de différentes ou de même longueur, et d'obtenir leurs XOR à ce que chaque octet est XORed séparément.

Pourquoi ne pas le cycle de la s2 clé et de l'appliquer à tous caractères de s1? Pourquoi s'appliquent uniquement à la dernière 3?

OriginalL'auteur Norsul Ronsul | 2013-07-01

  1. 12

    Utilisation binascii.unhexlify() de transformer votre hex chaînes de données binaires, puis XOR qui, en remontant à l'hex avec 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'

    Le réel XOR est appliquée par octet des données décodées (à l'aide de ord() et chr() aller et à partir de nombres entiers).

    Noter que, comme dans votre exemple, j'ai tronqué s1 être de la même longueur que s2 (en ignorant les caractères à partir du début de s1). Vous pouvez encoder tous de s1 avec une clé plus courte s2 par le vélo, les octets:

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

    Vous n'avez pas ont à utiliser unhexlify(), mais il est beaucoup plus facile de boucler sur s1 et s2 2 caractères à la fois, et à l'aide de int(twocharacters, 16) de tourner que dans des valeurs entières pour les opérations XOR.

    Le Python 3 version ci-dessus est un peu plus léger; utilisation bytes() au lieu de str.join() et vous pouvez déposer le chr() et ord() les appels que vous obtenez pour itérer sur les entiers directement:

    >>> 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'
    Merci pour votre réponse! Ce que je ne comprends pas, c'est cette partie: c1, c2 dans le zip(unhexlify(s1), cycle(unhexlify(s2))))) Le truc c'est que je suis nouveau sur le python et obtenir facilement les confondre. Je pense que le zip de la fonction a quelque chose à voir avec les tableaux, mais je ne sais pas comment ceux qui travaillent dans Python. D'ailleurs, j'ai pensé que pour les boucles ont un seul compteur, mais ici vous avez deux c1 et c2, qui aussi me confond.
    zip() prend d'entrée multiples séquences, et les paires de leurs éléments. Donc, il vous donne une séquence de [(s1[0], s2[0]), (s1[1], s2[1]), ...] avec chaque tuple formé en prenant les éléments de chaque séquence d'entrée lors de ce même indice.
    Parce que dans ce cas zip() a deux listes, chaque élément de sortie est un tuple avec les deux valeurs. Le for boucle déballe ces deux valeur (tout comme vous pouvez ne tuple déballage en affectation régulière, foo, bar = ('spam', 'eggs') attribue foo = 'spam' et bar = 'eggs'.
    Je vois maintenant, mais j'ai un autre problème maintenant :D. je ne comprends pas ce que vous avez fait dans la deuxième partie. Que signifie pour encoder tous de s1? et que signifie le cycle octets?
    Au lieu de simplement l'encodage à seulement 3 caractères ('llo' de 'Hello') avec les 3 personnages de votre clé (ask), nous coder tous de Hello par la réutilisation de la clé, en commençant par le début de nouveau lorsque vous atteignez la fin; H avec a, e avec s, l avec k, puis le cycle au début de nouveau et d'encoder les l avec a, et o avec s. Le itertools.cycle() méthode nous permet de mettre en œuvre le cyclisme s2 avec juste une fonction.

    OriginalL'auteur Martijn Pieters

  2. 6

    J'ai trouvé une solution très simple:

    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

    Il xor de la chaîne jusqu'à ce qu'un thème se termine

    Toujours, il m'énerve quand les gens ne pas utiliser builtin format. return format(result, 'x').

    OriginalL'auteur Pini Cheyni

  3. 1

    Je ne suis pas sûr de ce que vous êtes exactement à la recherche, mais j'espère que cela sera utile pour vous.

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

    De départ avec les deux normal des chaînes, vous pouvez trouver vos résultats en faisant quelque chose comme ceci:

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

    OriginalL'auteur Shaddy