Konvertieren Sie Python Long / Int in Bytearray fester Größe

Ich versuche, die Implementierung von RC4-und DH-Schlüsselaustausch in python. Problem ist, dass ich keine Ahnung habe wie konvertiert man die python-long/int vom Austausch der Schlüssel, um das byte-array brauche ich für den RC4-Implementierung. Gibt es eine einfache Möglichkeit zu konvertieren lange, um die gewünschte Länge der byte-array?

Update: vergaß zu erwähnen, dass die zahlen, die ich bin den Umgang mit 768 bit unsigned Integer.

InformationsquelleAutor der Frage cdecker | 2012-01-04

Ich habe nicht getan, alle benchmarks, aber dieses Rezept "funktioniert für mich".

Die kurze version: verwenden Sie '%x' % valdann unhexlify das Ergebnis. Der Teufel liegt im Detail, obwohl, wie unhexlify erfordert eine gerade Anzahl von hex-Ziffern, die %x garantiert nicht. Finden Sie unter den docstring, und die liberale inline-Kommentare für details.

from binascii import unhexlify

def long_to_bytes (val, endianness='big'):
    """
    Use :ref:`string formatting` and :func:`~binascii.unhexlify` to
    convert ``val``, a :func:`long`, to a byte :func:`str`.

    :param long val: The value to pack

    :param str endianness: The endianness of the result. ``'big'`` for
      big-endian, ``'little'`` for little-endian.

    If you want byte- and word-ordering to differ, you're on your own.

    Using :ref:`string formatting` lets us use Python's C innards.
    """

    # one (1) hex digit per four (4) bits
    width = val.bit_length()

    # unhexlify wants an even multiple of eight (8) bits, but we don't
    # want more digits than we need (hence the ternary-ish 'or')
    width += 8 - ((width % 8) or 8)

    # format width specifier: four (4) bits per hex digit
    fmt = '%%0%dx' % (width // 4)

    # prepend zero (0) to the width, to zero-pad the output
    s = unhexlify(fmt % val)

    if endianness == 'little':
        # see http://stackoverflow.com/a/931095/309233
        s = s[::-1]

    return s

...und meine nosetest unit tests 😉

class TestHelpers (object):
    def test_long_to_bytes_big_endian_small_even (self):
        s = long_to_bytes(0x42)
        assert s == '\x42'

        s = long_to_bytes(0xFF)
        assert s == '\xff'

    def test_long_to_bytes_big_endian_small_odd (self):
        s = long_to_bytes(0x1FF)
        assert s == '\x01\xff'

        s = long_to_bytes(0x201FF)
        assert s == '\x02\x01\xff'

    def test_long_to_bytes_big_endian_large_even (self):
        s = long_to_bytes(0xab23456c8901234567)
        assert s == '\xab\x23\x45\x6c\x89\x01\x23\x45\x67'

    def test_long_to_bytes_big_endian_large_odd (self):
        s = long_to_bytes(0x12345678901234567)
        assert s == '\x01\x23\x45\x67\x89\x01\x23\x45\x67'

    def test_long_to_bytes_little_endian_small_even (self):
        s = long_to_bytes(0x42, 'little')
        assert s == '\x42'

        s = long_to_bytes(0xFF, 'little')
        assert s == '\xff'

    def test_long_to_bytes_little_endian_small_odd (self):
        s = long_to_bytes(0x1FF, 'little')
        assert s == '\xff\x01'

        s = long_to_bytes(0x201FF, 'little')
        assert s == '\xff\x01\x02'

    def test_long_to_bytes_little_endian_large_even (self):
        s = long_to_bytes(0xab23456c8901234567, 'little')
        assert s == '\x67\x45\x23\x01\x89\x6c\x45\x23\xab'

    def test_long_to_bytes_little_endian_large_odd (self):
        s = long_to_bytes(0x12345678901234567, 'little')
        assert s == '\x67\x45\x23\x01\x89\x67\x45\x23\x01'

InformationsquelleAutor der Antwort Tripp Lilley

28

Mit Python 3.2 und höher verwenden, können Sie int.to_bytes und int.from_bytes: https://docs.python.org/3/library/stdtypes.html#int.to_bytes

InformationsquelleAutor der Antwort Jack O'Connor

One-liner:

bytearray.fromhex('{:0192x}'.format(big_int))

192 768 /4, weil die OP wollte 768-bit-zahlen und gibt es 4 bits in hex-Ziffer. Wenn Sie eine größere bytearray verwenden Sie eine format-string-mit einer höheren Zahl. Beispiel:

>>> big_int = 911085911092802609795174074963333909087482261102921406113936886764014693975052768158290106460018649707059449553895568111944093294751504971131180816868149233377773327312327573120920667381269572962606994373889233844814776702037586419
>>> bytearray.fromhex('{:0192x}'.format(big_int))
bytearray(b'\x96;h^\xdbJ\x8f3obL\x9c\xc2\xb0-\x9e\xa4Sj-\xf6i\xc1\x9e\x97\x94\x85M\x1d\x93\x10\\\x81\xc2\x89\xcd\xe0a\xc0D\x81v\xdf\xed\xa9\xc1\x83p\xdbU\xf1\xd0\xfeR)\xce\x07\xdepM\x88\xcc\x7fv\\\x1c\x8di\x87N\x00\x8d\xa8\xbd[<\xdf\xaf\x13z:H\xed\xc2)\xa4\x1e\x0f\xa7\x92\xa7\xc6\x16\x86\xf1\xf3')
>>> lepi_int = 0x963b685edb4a8f336f624c9cc2b02d9ea4536a2df669c19e9794854d1d93105c81c289cde061c0448176dfeda9c18370db55f1d0fe5229ce07de704d88cc7f765c1c8d69874e008da8bd5b3cdfaf137a3a48edc229a41e0fa792a7c61686f1f
>>> bytearray.fromhex('{:0192x}'.format(lepi_int))
bytearray(b'\tc\xb6\x85\xed\xb4\xa8\xf36\xf6$\xc9\xcc+\x02\xd9\xeaE6\xa2\xdff\x9c\x19\xe9yHT\xd1\xd91\x05\xc8\x1c(\x9c\xde\x06\x1c\x04H\x17m\xfe\xda\x9c\x187\r\xb5_\x1d\x0f\xe5"\x9c\xe0}\xe7\x04\xd8\x8c\xc7\xf7e\xc1\xc8\xd6\x98t\xe0\x08\xda\x8b\xd5\xb3\xcd\xfa\xf17\xa3\xa4\x8e\xdc"\x9aA\xe0\xfay*|aho\x1f')

[Meine Antwort benutzt hatte hex() vor. Korrigiert habe ich es mit format() um int-Werte mit odd-size-byte-Ausdrücke. Dies behebt vorherigen Beschwerden über ValueError.]

InformationsquelleAutor der Antwort Jess Austin

long/int zu byte-array aussieht genauen Zweck struct.pack. Für lange ganze zahlen, die mehr als 4(8) bytes, können Sie kommen mit so etwas wie das nächste:

>>> limit = 256*256*256*256 - 1
>>> i = 1234567890987654321
>>> parts = []
>>> while i:
        parts.append(i & limit)
        i >>= 32

>>> struct.pack('>' + 'L'*len(parts), *parts )
'\xb1l\x1c\xb1\x11"\x10\xf4'

>>> struct.unpack('>LL', '\xb1l\x1c\xb1\x11"\x10\xf4')
(2976652465L, 287445236)
>>> (287445236L << 32) + 2976652465L
1234567890987654321L

InformationsquelleAutor der Antwort Roman Bodnarchuk

7

Jeder hat kompliziert diese Antwort:
```
some_int = <256 bit integer>
some_bytes = some_int.to_bytes(32, sys.byteorder)
my_bytearray = bytearray(some_bytes)
```
Brauchen Sie nur zu wissen, die Anzahl der bytes, die Sie versuchen zu konvertieren. In meinem use-cases, normalerweise verwende ich nur diese großen zahlen für crypto, und an diesem Punkt habe ich zu befürchten, Elastizitätsmodul und was nicht, also ich glaube nicht, dass das ein großes problem werden, erforderlich, zu wissen, die maximale Anzahl von bytes zurück.

Da Sie es tun 768-bit-Mathematik, dann statt 32 wie das argument, es wäre 96.

InformationsquelleAutor der Antwort sparticvs
6

Können Sie versuchen, mit struct:
```
import struct
struct.pack('L',longvalue)
```
InformationsquelleAutor der Antwort Eduardo Ivanec
4

Little-endian, reverse das Ergebnis oder den Bereich, wenn Sie wollen, Big-endian.
```
def int_to_bytes(val, num_bytes):
    return [(val & (0xff << pos*8)) >> pos*8 for pos in range(num_bytes)]
```
InformationsquelleAutor der Antwort scornwell
3

Im Grunde, was Sie tun müssen, ist, konvertieren Sie die int/long in seine base 256 Darstellung, D. H. eine Zahl, deren "Ziffern" - range von 0-255. Hier ist eine ziemlich effiziente Möglichkeit, etwas zu tun:
```
def base256_encode(n, minwidth=0): # int/long to byte array
    if n > 0:
        arr = []
        while n:
            n, rem = divmod(n, 256)
            arr.append(rem)
        b = bytearray(reversed(arr))
    elif n == 0:
        b = bytearray(b'\x00')
    else:
        raise ValueError

    if minwidth > 0 and len(b) < minwidth: # zero padding needed?
        b = (minwidth-len(b)) * '\x00' + b
    return b
```
Ihnen viele nicht brauchen, diereversed()Anruf je nach endian-ness gewünscht (so würde dies erfordern, die Polsterung anders gemacht werden). Beachten Sie auch, dass, wie geschrieben es funktioniert nicht mit negativen zahlen.

Vielleicht möchten Sie auch einen Blick auf die ähnlich, aber hoch optimierte long_to_bytes() Funktion in dernumber.pyModul ist Teil der open-source -Python Cryptography Toolkit. Tatsächlich wandelt die Zahl in eine Zeichenfolge, die nicht ein byte-array, aber das ist ein kleines Problem.

InformationsquelleAutor der Antwort martineau
1

Python 2.7 implementiert nicht die int.- sehr slow_bytes () - Methode.

Versuchte ich 3 Methoden:
1. hex unpack/pack : sehr langsam
2. byte-Verschiebung von 8 bits zu einer Zeit: deutlich schneller.
3. mit einem "C" - Modul der Verpackung und in der unteren (7 ia64 oder 3 i32) bytes.
  Das war etwa doppelt so schnell wie 2/. Es ist die Schnellste option, aber immer noch zu langsam.
Alle diese Methoden sind sehr effektiv, aus zwei Gründen:
- Python 2.7 unterstützt dies nicht zweckdienlichen Betrieb.
- c nicht unterstützt extended-precision-Arithmetik mit der carry/borrow - /überlauf-flags auf den meisten Plattformen.
InformationsquelleAutor der Antwort GP Eckersley

-1

i = 0x12345678
s = struct.pack('<I',i)
b = struct.unpack('BBBB',s)

InformationsquelleAutor der Antwort user1025874

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.