Convert python long/int to fixed size byte array

With Python 3.2 and later, you can use int.to_bytes and int.from_bytes: https://docs.python.org/3/library/stdtypes.html#int.to_bytes

Everyone has overcomplicated this answer:

some_int = <256 bit integer> some_bytes = some_int.to_bytes(32, sys.byteorder) my_bytearray = bytearray(some_bytes) 

You just need to know the number of bytes that you are trying to convert. In my use cases, normally I only use this large of numbers for crypto, and at that point I have to worry about modulus and what-not, so I don't think this is a big problem to be required to know the max number of bytes to return.

Since you are doing it as 768-bit math, then instead of 32 as the argument it would be 96.

One-liner:

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

The 192 is 768 / 4, because OP wanted 768-bit numbers and there are 4 bits in a hex digit. If you need a bigger bytearray use a format string with a higher number. Example:

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

[My answer had used hex() before. I corrected it with format() in order to handle ints with odd-sized byte expressions. This fixes previous complaints about ValueError.]

long/int to the byte array looks like exact purpose of struct.pack. For long integers that exceed 4(8) bytes, you can come up with something like the next:

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

You can try using struct:

import struct struct.pack('L',longvalue) 

Little-endian, reverse the result or the range if you want Big-endian:

def int_to_bytes(val, num_bytes): return [(val & (0xff << pos*8)) >> pos*8 for pos in range(num_bytes)] 

Big-endian:

def int_to_bytes(val, num_bytes): return [(val & (0xff << pos*8)) >> pos*8 for pos in reversed(range(num_bytes))] 

Basically what you need to do is convert the int/long into its base 256 representation -- i.e. a number whose "digits" range from 0-255. Here's a fairly efficient way to do something like that:

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 

You many not need thereversed()call depending on the endian-ness desired (doing so would require the padding to be done differently as well). Also note that as written it doesn't handle negative numbers.

You might also want to take a look at the similar but highly optimized long_to_bytes() function in thenumber.pymodule which is part of the open source Python Cryptography Toolkit. It actually converts the number into a string, not a byte array, but that's a minor issue.

Python 2.7 does not implement the int.to- very slow_bytes() method.

I tried 3 methods:

1. hex unpack/pack : very slow
2. byte shifting 8 bits at a time: significantly faster.
3. using a "C" module and packing into the lower (7 ia64 or 3 i32) bytes. This was about twice as fast as 2/ . It is the fastest option, but still too slow.

All these methods are very inefficient for two reasons:

• Python 2.7 does not support this useful operation.
• c does not support extended precision arithmetic using the carry/borrow/overflow flags available on most platforms.

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

def bigIntToArray_v1(value): result = [] while True: result.insert(0, value % 256) value = value // 256 if value == 0: break return result def bigIntToArray_v2(value): result = [] while True: result.insert(0, value & 0b1111_1111) value = value >> 8 if value == 0: break return result 

Test

expected = [ 30, 119, 10, 234, 151, 91, 69, 198, 85, 193, 130, 94, 213, 16, 109, 151, 14, 129, 143, 64, 171, 172, 190, 28, 152, 247, 78, 21, 94, 76, 93, 58 ] result1 = bigIntToArray_v1(13779715600237310799632842054081955307819773220415101057149384327455163833658) result2 = bigIntToArray_v2(13779715600237310799632842054081955307819773220415101057149384327455163833658) print(result1 == expected) print(result2 == expected) print( bytearray(result1) ) print( bytearray(result2) )