我正在尝试在 python 中实现 RC4 和 DH 密钥交换。问题是我不知道如何将 python long/int 从密钥交换转换为 RC4 实现所需的字节数组。有没有一种简单的方法可以将 long 转换为所需长度的字节数组？
更新：忘了提到我正在处理的数字是 768 位无符号整数。
问问题
120929 次
10 回答
57
使用 Python 3.2 及更高版本，您可以使用int.to_bytesand int.from_bytes：https ://docs.python.org/3/library/stdtypes.html#int.to_bytes
于 2015-01-20T23:39:21.467 回答
23
每个人都把这个答案复杂化了：
some_int = <256 bit integer>
some_bytes = some_int.to_bytes(32, sys.byteorder)
my_bytearray = bytearray(some_bytes)
您只需要知道您尝试转换的字节数。在我的用例中，通常我只使用这么大的数字进行加密，此时我不得不担心模数和其他问题，所以我认为知道最大数字不是一个大问题要返回的字节数。
由于您将其作为 768 位数学运算，因此参数将不是 32，而是 96。
于 2015-08-14T15:22:04.250 回答
20
我没有做过任何基准测试，但这个食谱“对我有用”。
简短版本：使用'%x' % val，然后unhexlify是结果。但是，魔鬼在细节中，因为unhexlify需要偶数个十六进制数字，这%x并不能保证。有关详细信息，请参阅文档字符串和自由的内联注释。
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
...和我的鼻子测试单元测试;-)
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'
于 2013-01-25T17:18:19.437 回答
14
单线：
bytearray.fromhex('{:0192x}'.format(big_int))
192 是 768 / 4，因为 OP 想要 768 位数字并且十六进制数字中有 4 位。如果您需要更大的数字，请bytearray使用具有更高数字的格式字符串。例子：
>>> 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')
[我的答案以前用过hex()。format()为了处理具有奇数字节表达式的整数，我对其进行了更正。这解决了之前关于 .] 的投诉ValueError。]
于 2013-07-30T14:28:16.150 回答
8
字节数组的 long/int看起来就像struct.pack. 对于超过 4(8) 个字节的长整数，您可以想出如下内容：
>>> 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
于 2012-01-04T17:33:04.127 回答
7
您可以尝试使用struct：
import struct
struct.pack('L',longvalue)
于 2012-01-04T17:31:59.160 回答
7
小端，如果你想要大端，反转结果或范围：
def int_to_bytes(val, num_bytes):
return [(val & (0xff << pos*8)) >> pos*8 for pos in range(num_bytes)]
大端：
def int_to_bytes(val, num_bytes):
return [(val & (0xff << pos*8)) >> pos*8 for pos in reversed(range(num_bytes))]
于 2013-01-30T20:32:26.100 回答
3
基本上，您需要做的是将 int/long 转换为其基本 256 表示形式——即“数字”范围为 0-255 的数字。这是一种相当有效的方法来做这样的事情：
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
根据所需的字节序，很多人不需要reversed()调用（这样做也需要以不同的方式完成填充）。另请注意，正如所写，它不处理负数。
您可能还想看看模块中类似但高度优化long_to_bytes()的功能，number.py它是开源Python Cryptography Toolkit的一部分。它实际上将数字转换为字符串，而不是字节数组，但这是一个小问题。
于 2012-01-04T21:32:56.127 回答
2
Python 2.7 没有实现 int.to-very slow_bytes() 方法。
我尝试了 3 种方法：
- 十六进制解包/打包：非常慢
- 一次字节移位 8 位：明显更快。
- 使用“C”模块并打包到较低的（7 ia64 或 3 i32）字节中。这大约是 2/ 的两倍。这是最快的选择，但仍然太慢。
所有这些方法都非常低效，原因有两个：
- Python 2.7 不支持这种有用的操作。
- c 不支持使用大多数平台上可用的进位/借位/溢出标志的扩展精度算术。
于 2015-10-20T00:56:01.963 回答
0
i = 0x12345678
s = struct.pack('<I',i)
b = struct.unpack('BBBB',s)
于 2017-11-14T12:11:15.113 回答