Is there a predictable replacement for os.urandom using Python's random module?

Question

I'm looking to get n random bytes as a bytearray or bytes, as os.urandom does.

However I need to be able to set a random seed so the value is reproducable.

def urandom_from_random(rng, length):
    return bytes([rng.randint(0, 255) for i in range(length)])

import random
rng = random.Random(42)
data = urandom_from_random(rng, 120)
print(data)

The script above works, but isn't very efficient.

Is there a more direct way to do this besides creating many ints and converting them to bytes?

---

Note:

• Making urandom return predictable results is possible on Linux, but needs root access.

Answer 1

I think the closest function in random to what you want is getrandbits. It returns an integer with the requested number of bits. If you want to turn that into a bytes instance, you can use int.to_bytes.

Here's a quick function that pairs those two together:

def urandom_from_random(rng, length):
    if length == 0:
        return b''
    integer = rng.getrandbits(length * 8)
    result = integer.to_bytes(length, sys.byteorder)
    return result

The byte order you specify to to_bytes shouldn't matter. I tell it to use the system's native byte order, but I don't actually know if that makes it any faster than it would be otherwise.

Answer 2

This is a modified version of @Blckknght's answer that takes into account the internal INT_MAX limit in getrandbits.

def urandom_from_random(rng, length):
    if length == 0:
        return b''

    import sys
    chunk_size = 65535
    chunks = []
    while length >= chunk_size:
        chunks.append(rng.getrandbits(
                chunk_size * 8).to_bytes(chunk_size, sys.byteorder))
        length -= chunk_size
    if length:
        chunks.append(rng.getrandbits(
                length * 8).to_bytes(length, sys.byteorder))
    result = b''.join(chunks)
    return result

Example use:

import random 
rng = random.Random(42)
print(len(urandom_from_random(rng, 300000000)))