Mailman 3 - Security-SIG

new TLS module
by Ethan Furman 12 Jan '17

12 Jan '17

With TLSv1.2 becoming mandatory in the near future and the various issues with the ssl module there is more interest in a tls module for Python. What should such a module include? What should it not include? Any reason to not also have a backport of this module? -- ~Ethan~

2 1

Lack of IDNA 2008 support
by Christian Heimes 12 Oct '16

12 Oct '16

Hi, Python has only IDNA 2003 support (international domain names). I'm starting to consider Python's lack of IDNA 2008 support a security issue for DNS lookups and for cert validation. Applications may connect to the wrong IP address and validate the hostname, too. IDNA 2008 is mandatory for German .de domains. See https://bugs.python.org/issue17305 Wrong: >>> import socket >>> u'straße.de'.encode('idna') 'strasse.de' >>> socket.gethostbyname(u'straße.de'.encode('idna')) '72.52.4.119' Correct: >>> import idna >>> idna.encode(u'straße.de') 'xn--strae-oqa.de' >>> socket.gethostbyname(idna.encode(u'straße.de')) '81.169.145.78' I neither have time nor expertise to implement IDNA 2008. The ticket 17305 is more than three years old, too. Christian

3 3

Pending security features for 3.6
by Christian Heimes 26 Aug '16

26 Aug '16

Hi, (2nd attempt, first mail didn't make it) I have a bunch of tickets with security-related improvements or features for Python 3.6. Most of the tickets come with patches and tests. Some of the patches might be outdated or conflict with tip. I have branches on my private github fork for all patches. Please review the patches and decide which features you like to include in future releases. Make ssl module compatible with OpenSSL 1.1.0 --------------------------------------------- http://bugs.python.org/issue26470 https://github.com/tiran/cpython/commits/feature/openssl110 https://github.com/tiran/cpython/commits/feature/openssl110_27 OpenSSL 1.1.0 changes several APIs, e.g. it makes structs opaque. The ticket has patches for 2.7 and 3.x series. It should be applied to all Python versions that are open for security patches. Add ChaCha20 Poly1305 to SSL ciphers ------------------------------------ http://bugs.python.org/issue27766 https://github.com/tiran/cpython/commits/feature/chacha20 The ticket changes the default cipher list and moves ChaCha20 Poly1305 up front. For now the patch makes only sense with OpenSSL 1.1.0 since 1.0.2 does not include the cipher. I expect to see backports, though. It should be applied to all Python versions, too. ssl: add public API for IA-32 processor capabilities vector ----------------------------------------------------------- http://bugs.python.org/issue27768 This ticket doesn't have a patch yet. I'm going to move code from ticket 27766 to a separate ticket. Alex and Cory have requested to make the API public. Add AF_ALG (Linux Kernel crypto) to socket module ------------------------------------------------- http://bugs.python.org/issue27744 https://github.com/tiran/cpython/commits/feature/af_alg AF_ALG is a Linux-only socket it to interface with Kernel space crypto. It's limited but has a couple of really useful properties, e.g. zero-copy hashing of files with sendfile() or storing key material securely in Kernel memory. Add BLAKE2 to hashlib --------------------- http://bugs.python.org/issue26798 https://github.com/tiran/cpython/commits/feature/blake2 BLAKE2 is a fast and powerful hash algorithm. It's as secure as SHA-2 family, faster than MD5 and has built-in features like MAC support, variable output length, salting and personalization. Donald uses BLAKE2 for PyPI. The patch was refused on python-dev because it introduces too much new code. Add SHA-3 and SHAKE (Keccak) support ------------------------------------ http://bugs.python.org/issue16113 https://github.com/tiran/cpython/commits/feature/sha3 SHA-3 is the successor of SHA-2. Like BLAKE2 the patch was refused on python-dev because it introduces too much new code. Add truncated SHA512/224 and SHA512/256 --------------------------------------- http://bugs.python.org/issue26834 https://github.com/tiran/cpython/commits/feature/sha512truncated Truncated SHA512/224 and SHA512/256 use the SHA512 algorithm instead of SHA256 algorithm. Like SHA384 it's SHA512 with a different init vector and truncated output. Christian

5 5

Implementation of the PEP 524
by Victor Stinner 19 Aug '16

19 Aug '16

Hi, I wrote a first implementation of the PEP 524 (make os.urandom blocking): * https://bugs.python.org/issue27776 : "PEP 524: Make os.urandom() blocking on Linux" * https://bugs.python.org/issue27778 : "PEP 524: Add os.getrandom()" My patches are now waiting for your review :-) You should also review changes made to prepare the issue #27776: https://hg.python.org/cpython/rev/980e2c781810 https://hg.python.org/cpython/rev/265644bad99e https://hg.python.org/cpython/rev/86d0d74bc2e1 https://hg.python.org/cpython/rev/ad141164c792 The last change (close fd on error) is not a really bugfix, it's more a new feature. In Python 3.5, it wasn't needed to close the file descriptor since Py_FatalError() was called immediatly. Victor

2 5

Take a decision for os.urandom() in Python 3.6
by Victor Stinner 08 Aug '16

08 Aug '16

Hi, Would it be possible to take a decision on the PEP 522 and PEP 524? Deadline for new features in Python 3.6 is in one month or something like that, no? My PEP: https://www.python.org/dev/peps/pep-0524/ "PEP 524 -- Make os.urandom() blocking on Linux" Nick's PEP: https://www.python.org/dev/peps/pep-0522/ "PEP 522 -- Allow BlockingIOError in security sensitive APIs" Victor

7 28

PEP 524: Make os.urandom() blocking on Linux (version 3)
by Victor Stinner 30 Jul '16

30 Jul '16

Hi, I moved my os.urandom PEP to the regular GitHub repository so it gets available on python.org: https://www.python.org/dev/peps/pep-0524/ Changes since version 2: * add os.getrandom() * random.Random now always use non-blocking system urandom and so remove the "Never use blocking urandom in the random module" section * add a new "Examples using os.getrandom()" section * various fixes and minor updates Victor PEP: 524 Title: Make os.urandom() blocking on Linux Version: $Revision$ Last-Modified: $Date$ Author: Victor Stinner <victor.stinner(a)gmail.com> Status: Draft Type: Standards Track Content-Type: text/x-rst Created: 20-June-2016 Python-Version: 3.6 Abstract ======== Modify ``os.urandom()`` to block on Linux 3.17 and newer until the OS urandom is initialized to increase the security. Add also a new ``os.getrandom()`` function (for Linux and Solaris) to be able to choose how to handle when ``os.urandom()`` is going to block on Linux. The bug ======= Original bug ------------ Python 3.5.0 was enhanced to use the new ``getrandom()`` syscall introduced in Linux 3.17 and Solaris 11.3. The problem is that users started to complain that Python 3.5 blocks at startup on Linux in virtual machines and embedded devices: see issues `#25420 <http://bugs.python.org/issue25420>`_ and `#26839 <http://bugs.python.org/issue26839>`_. On Linux, ``getrandom(0)`` blocks until the kernel initialized urandom with 128 bits of entropy. The issue #25420 describes a Linux build platform blocking at ``import random``. The issue #26839 describes a short Python script used to compute a MD5 hash, systemd-cron, script called very early in the init process. The system initialization blocks on this script which blocks on ``getrandom(0)`` to initialize Python. The Python initilization requires random bytes to implement a counter-measure against the hash denial-of-service (hash DoS), see: * `Issue #13703: Hash collision security issue <http://bugs.python.org/issue13703>`_ * `PEP 456: Secure and interchangeable hash algorithm <https://www.python.org/dev/peps/pep-0456/>`_ Importing the ``random`` module creates an instance of ``random.Random``: ``random._inst``. On Python 3.5, random.Random constructor reads 2500 bytes from ``os.urandom()`` to seed a Mersenne Twister RNG (random number generator). Other platforms may be affected by this bug, but in practice, only Linux systems use Python scripts to initialize the system. Status in Python 3.5.2 ---------------------- Python 3.5.2 behaves like Python 2.7 and Python 3.4. If the system urandom is not initialized, the startup does not block, but ``os.urandom()`` can return low-quality entropy (even it is not easily guessable). Use Cases ========= The following use cases are used to help to choose the right compromise between security and practicability. Use Case 1: init script ----------------------- Use a Python 3 script to initialize the system, like systemd-cron. If the script blocks, the system initialize is stuck too. The issue #26839 is a good example of this use case. Use case 1.1: No secret needed ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If the init script doesn't have to generate any secure secret, this use case is already handled correctly in Python 3.5.2: Python startup doesn't block on system urandom anymore. Use case 1.2: Secure secret required ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If the init script has to generate a secure secret, there is no safe solution. Falling back to weak entropy is not acceptable, it would reduce the security of the program. Python cannot produce itself secure entropy, it can only wait until system urandom is initialized. But in this use case, the whole system initialization is blocked by this script, so the system fails to boot. The real answer is that the system iniitalization must not be blocked by such script. It is ok to start the script very early at system initialization, but the script may blocked a few seconds until it is able to generate the secret. Reminder: in some cases, the initialization of the system urandom never occurs and so programs waiting for system urandom blocks forever. Use Case 2: Web server ---------------------- Run a Python 3 web server serving web pages using HTTP and HTTPS protocols. The server is started as soon as possible. The first target of the hash DoS attack was web server: it's important that the hash secret cannot be easily guessed by an attacker. If serving a web page needs a secret to create a cookie, create an encryption key, ..., the secret must be created with good entropy: again, it must be hard to guess the secret. A web server requires security. If a choice must be made between security and running the server with weak entropy, security is more important. If there is no good entropy: the server must block or fail with an error. The question is if it makes sense to start a web server on a host before system urandom is initialized. The issues #25420 and #26839 are restricted to the Python startup, not to generate a secret before the system urandom is initialized. Fix system urandom ================== Load entropy from disk at boot ------------------------------- Collecting entropy can take up to several minutes. To accelerate the system initialization, operating systems store entropy on disk at shutdown, and then reload entropy from disk at the boot. If a system collects enough entropy at least once, the system urandom will be initialized quickly, as soon as the entropy is reloaded from disk. Virtual machines ---------------- Virtual machines don't have a direct access to the hardware and so have less sources of entropy than bare metal. A solution is to add a `virtio-rng device <https://fedoraproject.org/wiki/Features/Virtio_RNG>`_ to pass entropy from the host to the virtual machine. Embedded devices ---------------- A solution for embedded devices is to plug an hardware RNG. For example, Raspberry Pi have an hardware RNG but it's not used by default. See: `Hardware RNG on Raspberry Pi <http://fios.sector16.net/hardware-rng-on-raspberry-pi/>`_. Denial-of-service when reading random ===================================== Don't use /dev/random but /dev/urandom -------------------------------------- The ``/dev/random`` device should only used for very specific use cases. Reading from ``/dev/random`` on Linux is likely to block. Users don't like when an application blocks longer than 5 seconds to generate a secret. It is only expected for specific cases like generating explicitly an encryption key. When the system has no available entropy, choosing between blocking until entropy is available or falling back on lower quality entropy is a matter of compromise between security and practicability. The choice depends on the use case. On Linux, ``/dev/urandom`` is secure, it should be used instead of ``/dev/random``. See `Myths about /dev/urandom <http://www.2uo.de/myths-about-urandom/>`_ by Thomas Hühn: "Fact: /dev/urandom is the preferred source of cryptographic randomness on UNIX-like systems" getrandom(size, 0) can block forever on Linux --------------------------------------------- The origin of the Python issue #26839 is the `Debian bug report #822431 <https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=822431>`_: in fact, ``getrandom(size, 0)`` blocks forever on the virtual machine. The system succeeded to boot because systemd killed the blocked process after 90 seconds. Solutions like `Load entropy from disk at boot`_ reduces the risk of this bug. Rationale ========= On Linux, reading the ``/dev/urandom`` can return "weak" entropy before urandom is fully initialized, before the kernel collected 128 bits of entropy. Linux 3.17 adds a new ``getrandom()`` syscall which allows to block until urandom is initialized. On Python 3.5.2, os.urandom() uses the ``getrandom(size, GRND_NONBLOCK)``, but falls back on reading the non-blocking ``/dev/urandom`` if ``getrandom(size, GRND_NONBLOCK)`` fails with ``EAGAIN``. Security experts promotes ``os.urandom()`` to genereate cryptographic keys because it is implemented with a `Cryptographically secure pseudo-random number generator (CSPRNG) <https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_…>`_. By the way, ``os.urandom()`` is preferred over ``ssl.RAND_bytes()`` for different reasons. This PEP proposes to modify os.urandom() to use ``getrandom()`` in blocking mode to not return weak entropy, but also ensure that Python will not block at startup. Changes ======= Make os.urandom() blocking on Linux ----------------------------------- All changes described in this section are specific to the Linux platform. Changes: * Modify os.urandom() to block until system urandom is initialized: ``os.urandom()`` (C function ``_PyOS_URandom()``) is modified to always call ``getrandom(size, 0)`` (blocking mode) on Linux and Solaris. * Add a new private ``_PyOS_URandom_Nonblocking()`` function: try to call ``getrandom(size, GRND_NONBLOCK)`` on Linux and Solaris, but falls back on reading ``/dev/urandom`` if it fails with ``EAGAIN``. * Initialize hash secret from non-blocking system urandom: ``_PyRandom_Init()`` is modified to call ``_PyOS_URandom_Nonblocking()``. * ``random.Random`` constructor now uses non-blocking system urandom: it is modified to use internally the new ``_PyOS_URandom_Nonblocking()`` function to seed the RNG. Add a new os.getrandom() function --------------------------------- A new ``os.getrandom(size, flags=0)`` function is added: use ``getrandom()`` syscall on Linux and ``getrandom()`` C function on Solaris. The function comes with 2 new flags: * ``os.GRND_RANDOM``: read bytes from ``/dev/random`` rather than reading ``/dev/urandom`` * ``os.GRND_NONBLOCK``: raise a BlockingIOError if ``os.getrandom()`` would block The ``os.getrandom()`` is a thin wrapper on the ``getrandom()`` syscall/C function and so inherit of its behaviour. For example, on Linux, it can return less bytes than requested if the syscall is interrupted by a signal. Examples using os.getrandom() ============================= Best-effort RNG --------------- Example of a portable non-blocking RNG function: try to get random bytes from the OS urandom, or fallback on the random module. :: def best_effort_rng(size): # getrandom() is only available on Linux and Solaris if not hasattr(os, 'getrandom'): return os.urandom(size) result = bytearray() try: # need a loop because getrandom() can return less bytes than # requested for different reasons while size: data = os.getrandom(size, os.GRND_NONBLOCK) result += data size -= len(data) except BlockingIOError: # OS urandom is not initialized yet: # fallback on the Python random module data = bytes(random.randrange(256) for byte in range(size)) result += data return bytes(result) This function *can* block in theory on a platform where ``os.getrandom()`` is not available but ``os.urandom()`` can block. wait_for_system_rng() --------------------- Example of function waiting *timeout* seconds until the OS urandom is initialized on Linux or Solaris:: def wait_for_system_rng(timeout, interval=1.0): if not hasattr(os, 'getrandom'): return deadline = time.monotonic() + timeout while True: try: os.getrandom(1, os.GRND_NONBLOCK) except BlockingIOError: pass else: return if time.monotonic() > deadline: raise Exception('OS urandom not initialized after %s seconds' % timeout) time.sleep(interval) This function is *not* portable. For example, ``os.urandom()`` can block on FreeBSD in theory, at the early stage of the system initialization. Create a best-effort RNG ------------------------ Simpler example to create a non-blocking RNG on Linux: choose between ``Random.SystemRandom`` and ``Random.Random`` depending if ``getrandom(size)`` would block. :: def create_nonblocking_random(): if not hasattr(os, 'getrandom'): return random.Random() try: os.getrandom(1, os.GRND_NONBLOCK) except BlockingIOError: return random.Random() else: return random.SystemRandom() This function is *not* portable. For example, ``random.SystemRandom`` can block on FreeBSD in theory, at the early stage of the system initialization. Alternative =========== Leave os.urandom() unchanged, add os.getrandom() ------------------------------------------------ os.urandom() remains unchanged: never block, but it can return weak entropy if system urandom is not initialized yet. Only add the new ``os.getrandom()`` function (wrapper to the ``getrandom()`` syscall/C function). The ``secrets.token_bytes()`` function should be used to write portable code. The problem with this change is that it expects that users understand well security and know well each platforms. Python has the tradition of hiding "implementation details". For example, ``os.urandom()`` is not a thin wrapper to the ``/dev/urandom`` device: it uses ``CryptGenRandom()`` on Windows, it uses ``getentropy()`` on OpenBSD, it tries ``getrandom()`` on Linux and Solaris or falls back on reading ``/dev/urandom``. Python already uses the best available system RNG depending on the platform. This PEP does not change the API: * ``os.urandom()``, ``random.SystemRandom`` and ``secrets`` for security * ``random`` module (except ``random.SystemRandom``) for all other usages Raise BlockingIOError in os.urandom() ------------------------------------- Proposition ^^^^^^^^^^^ `PEP 522: Allow BlockingIOError in security sensitive APIs on Linux <https://www.python.org/dev/peps/pep-0522/>`_. Python should not decide for the developer how to handle `The bug`_: raising immediatly a ``BlockingIOError`` if ``os.urandom()`` is going to block allows developers to choose how to handle this case: * catch the exception and falls back to a non-secure entropy source: read ``/dev/urandom`` on Linux, use the Python ``random`` module (which is not secure at all), use time, use process identifier, etc. * don't catch the error, the whole program fails with this fatal exception More generally, the exception helps to notify when sometimes goes wrong. The application can emit a warning when it starts to wait for ``os.urandom()``. Criticism ^^^^^^^^^ For the use case 2 (web server), falling back on non-secure entropy is not acceptable. The application must handle ``BlockingIOError``: poll ``os.urandom()`` until it completes. Example:: def secret(n=16): try: return os.urandom(n) except BlockingIOError: pass print("Wait for system urandom initialiation: move your " "mouse, use your keyboard, use your disk, ...") while 1: # Avoid busy-loop: sleep 1 ms time.sleep(0.001) try: return os.urandom(n) except BlockingIOError: pass For correctness, all applications which must generate a secure secret must be modified to handle ``BlockingIOError`` even if `The bug`_ is unlikely. The case of applications using ``os.urandom()`` but don't really require security is not well defined. Maybe these applications should not use ``os.urandom()`` at the first place, but always the non-blocking ``random`` module. If ``os.urandom()`` is used for security, we are back to the use case 2 described above: `Use Case 2: Web server`_. If a developer doesn't want to drop ``os.urandom()``, the code should be modified. Example:: def almost_secret(n=16): try: return os.urandom(n) except BlockingIOError: return bytes(random.randrange(256) for byte in range(n)) The question is if `The bug`_ is common enough to require that so many applications have to be modified. Another simpler choice is to refuse to start before the system urandom is initialized:: def secret(n=16): try: return os.urandom(n) except BlockingIOError: print("Fatal error: the system urandom is not initialized") print("Wait a bit, and rerun the program later.") sys.exit(1) Compared to Python 2.7, Python 3.4 and Python 3.5.2 where os.urandom() never blocks nor raise an exception on Linux, such behaviour change can be seen as a major regression. Add an optional block parameter to os.urandom() ----------------------------------------------- See the `issue #27250: Add os.urandom_block() <http://bugs.python.org/issue27250>`_. Add an optional block parameter to os.urandom(). The default value may be ``True`` (block by default) or ``False`` (non-blocking). The first technical issue is to implement ``os.urandom(block=False)`` on all platforms. Only Linux 3.17 (and newer) and Solaris 11.3 (and newer) have a well defined non-blocking API (``getrandom(size, GRND_NONBLOCK)``). As `Raise BlockingIOError in os.urandom()`_, it doesn't seem worth it to make the API more complex for a theorical (or at least very rare) use case. As `Leave os.urandom() unchanged, add os.getrandom()`_, the problem is that it makes the API more complex and so more error-prone. Annexes ======= Operating system random functions --------------------------------- ``os.urandom()`` uses the following functions: * `OpenBSD: getentropy() <http://man.openbsd.org/OpenBSD-current/man2/getentropy.2>`_ (OpenBSD 5.6) * `Linux: getrandom() <http://man7.org/linux/man-pages/man2/getrandom.2.html>`_ (Linux 3.17) -- see also `A system call for random numbers: getrandom() <https://lwn.net/Articles/606141/>`_ * Solaris: `getentropy() <https://docs.oracle.com/cd/E53394_01/html/E54765/getentropy-2.html#scrolltoc>`_, `getrandom() <https://docs.oracle.com/cd/E53394_01/html/E54765/getrandom-2.html>`_ (both need Solaris 11.3) * UNIX, BSD: /dev/urandom, /dev/random * Windows: `CryptGenRandom() <https://msdn.microsoft.com/en-us/library/windows/desktop/aa379942%28v=vs.85…>`_ (Windows XP) On Linux, commands to get the status of ``/dev/random`` (results are number of bytes):: $ cat /proc/sys/kernel/random/entropy_avail 2850 $ cat /proc/sys/kernel/random/poolsize 4096 Why using os.urandom()? ----------------------- Since ``os.urandom()`` is implemented in the kernel, it doesn't have issues of user-space RNG. For example, it is much harder to get its state. It is usually built on a CSPRNG, so even if its state is "stolen", it is hard to compute previously generated numbers. The kernel has a good knowledge of entropy sources and feed regulary the entropy pool. That's also why ``os.urandom()`` is preferred over ``ssl.RAND_bytes()``. Copyright ========= This document has been placed in the public domain.

3 12

How to document changes related to security in Python changelog?
by Victor Stinner 28 Jul '16

28 Jul '16

Hi, I read the summary of Christian Heimes's talk at the language summit: "The Python security response team" http://lwn.net/Articles/691308/ Extract: "Some of the problems that have occurred are things like bug reports being sent to the list, but that couldn't be reproduced, or distributions not updating their Python packages because it wasn't clear to them that there was a security fix made in an upstream release. Heimes suggested that security fixes be clearly marked in the "News" file that accompanies releases." I suggest to add a new Security section to Misc/NEWS. So packagers should be able to quickly identify changes which should be backported (if they maintain a Python version which is no more supported upstream, or if you cannot use the latest version). Christian proposed to simply prefix changes with "[Security]". What do you think? Victor

3 6

Does the buildtime HAVE_GETRANDOM_SYSCALL check actually make sense?
by Nick Coghlan 03 Jul '16

03 Jul '16

I think I've found a better explanation than mere timing or coincidence for why we haven't had any problem reports regarding Python 3.5.1 blocking in Fedora or in the Software Collections builds for RHEL and CentOS: those builds currently aren't even trying to use the new syscall, and are instead always using the older non-blocking /dev/urandom behaviour. My assumption in https://bugzilla.redhat.com/show_bug.cgi?id=1350123 is that this is due to those binaries being built against a version of the kernel that doesn't have that syscall defined, which means the config script doesn't define HAVE_GETRANDOM_SYSCALL, which means we compile out the code that tries calling it at runtime. Does skipping trying the new syscall at runtime just because the build server is running an older kernel actually make sense? Or we would be better off defining a different TRY_GETRANDOM_SYSCALL that looks for some other indicator that this is a build for a platform where getrandom() might be available at runtime, even if it's not available at build time. Cheers, Nick. -- Nick Coghlan | ncoghlan(a)gmail.com | Brisbane, Australia

2 3

PEP 522 (v2): Allow BlockingIOError in security sensitive APIs
by Nick Coghlan 25 Jun '16

25 Jun '16

I've posted a new version of PEP 522 that adds secrets.wait_for_system_rng(). Full version inline below for ease of quoting, but if you just want to see the diff: https://github.com/python/peps/commit/ace74fca2a9a0cf9a01d38247b15d37b7c0e7… The major flow on change from that is simplifying the "What to do?" recommendations, which are now simply: - security sensitive applications should either let the exception fly or call secrets.wait_for_system_rng() - non-security sensitive applications should switch to using the random module I've also tried to document the impact on other operating systems that also offer the getrandom() syscall, and explicitly referenced the fact that the likely reason we haven't heard anything from the Fedora/RHEL/CentOS worlds is because those builds haven't enabled the new behaviour due to the way their respective build systems work. Cheers, Nick. ====================================== PEP: 522 Title: Allow BlockingIOError in security sensitive APIs Version: $Revision$ Last-Modified: $Date$ Author: Nick Coghlan <ncoghlan(a)gmail.com>, Nathaniel J. Smith <njs(a)pobox.com> Status: Draft Type: Standards Track Content-Type: text/x-rst Requires: 506 Created: 16 June 2016 Python-Version: 3.6 Abstract ======== A number of APIs in the standard library that return random values nominally suitable for use in security sensitive operations currently have an obscure operating system dependent failure mode that allows them to return values that are not, in fact, suitable for such operations. This is due to some operating system kernels (most notably the Linux kernel) permitting reads from ``/dev/urandom`` before the system random number generator is fully initialized, whereas most other operating systems will implicitly block on such reads until the random number generator is ready. This PEP proposes changing such failures in Python 3.6 from the current silent, hard to detect, and hard to debug, errors to easily detected and debugged errors by raising ``BlockingIOError`` with a suitable error message, allowing developers the opportunity to unambiguously specify their preferred approach for handling the situation. This change will impact any operating system that offers the ``getrandom()`` system call, regardless of whether the default behaviour of the ``/dev/urandom`` device is to return potentially predictable results when the system random number generator is not ready (e.g. Linux, NetBSD) or to block (e.g. FreeBSD, Solaris, Illumos). Operating systems that prevent execution of userspace code prior to the initialization of the system random number generator, or do not offer the ``getrandom()`` syscall, will be entirely unaffected by the proposed change (e.g. Windows, Mac OS X, OpenBSD). The APIs affected by this change would be: * ``os.urandom`` * ``random.SystemRandom`` * the new ``secrets`` module added by PEP 506 A new ``secrets.wait_for_system_rng()`` API would be added to allow affected applications, frameworks and scripts that encounter the new exception to readily opt-in to blocking behaviour if they so choose, either by modifying the affected application directly, or by running a preceding ``python3 -c "import secrets; secrets.wait_for_system_rng()"`` command. The new exception would potentially be encountered in the following situations: * Python code calling these APIs during Linux system initialization * Python code running on improperly initialized Linux systems (e.g. embedded hardware without adequate sources of entropy to seed the system random number generator, or Linux VMs that aren't configured to accept entropy from the VM host) CPython interpreter initialization and ``random`` module initialization would also be updated to gracefully fall back to alternative seeding options if the system random number generator is not ready. Relationship with other PEPs ============================ This PEP depends on the Accepted PEP 506, which adds the ``secrets`` module. This PEP competes with Victor Stinner's `currently unnumbered proposal <http://haypo-notes.readthedocs.io/pep_random.html>`_ to make ``os.urandom`` implicitly block when the system RNG is not ready. Proposal ======== Changing ``os.urandom()`` on platforms with the getrandom() system call ----------------------------------------------------------------------- This PEP proposes that in Python 3.6+, ``os.urandom()`` be updated to call the ``getrandom()`` syscall in non-blocking mode if available and raise ``BlockingIOError: system random number generator is not ready`` if the kernel reports that the call would block. This behaviour will then propagate through to higher level standard library APIs that depend on ``os.urandom`` (specifically ``random.SystemRandom`` and the new ``secrets`` module introduced by PEP 506). In all cases, as soon as a call to one of these security sensitive APIs succeeds, all future calls to these APIs in that process will succeed (once the operating system random number generator is ready after system boot, it remains ready). On Linux and NetBSD, this will replace the previous behaviour of returning potentially predictable results read from ``/dev/urandom``. On FreeBSD, Solaris, and Illumos, this will replace the previous behaviour of implicitly blocking until the system random number generator is ready. However, it is not clear if these operating systems actually allow userspace code (and hence Python) to run before the system random number generator is ready. Note that in all cases, if calling the ``getrandom()`` API reports ``ENOSYS`` rather than returning a successful response or reporting ``EAGAIN``, CPython will continue to fall back to reading from ``/dev/urandom`` directly. Adding ``secrets.wait_for_system_rng()`` ---------------------------------------- A new exception shouldn't be added without a straightforward recommendation for how to resolve that error when encountered (however rare encountering the new error is expected to be in practice). For security sensitive code that actually does need to use the system random number generator, and does receive live bug reports indicating this is a real problem for the userbase of that particular application rather than a theoretical one, this PEP's recommendation will be to add the following snippet (directly or indirectly) to the ``__main__`` module:: import secrets secrets.wait_for_system_rng() Or, if compatibility with versions prior to Python 3.6 is needed:: try: import secrets except ImportError: pass else: secrets.wait_for_system_rng() Application frameworks covering use cases where access to the system random number generator is almost certain to be needed (e.g. web frameworks) may choose to incorporate this step implicitly into the commands that start the application. For cases where the error is encountered for an application which cannot be modified directly, then the following command can be used to wait for the system random number generator to initialize before starting that application:: python3 -c "import secrets; secrets.wait_for_system_rng()" For example, this snippet could be added to a shell script or a systemd ``ExecStartPre`` hook (and may prove useful in reliably waiting for the system random number generator to be ready, even if the subsequent command is not itself an application running under Python 3.6) Given the changes proposed to ``os.urandom()`` above, the suggested implementation of this function would be:: def wait_for_system_rng(): """Block waiting for system random number generator to be ready""" # If the system RNG is already seeded, don't wait at all try: os.urandom(1) return except BlockingIOError: pass # Avoid the below busy loop if possible try: block_on_system_rng = open("/dev/random", "rb") except FileNotFoundError: pass else: with block_on_system_rng: block_on_system_rng.read(1) # Busy loop until the system RNG is ready while True: try: os.urandom(1) break except BlockingIOError: # Only check once per millisecond time.sleep(0.001) On systems where it is possible to wait for the system RNG to be ready, this function will do so without a busy loop if either ``os.urandom()`` itself implicitly blocks, or the ``/dev/random`` device is available. If the system random number generator is ready, this call is guaranteed to never block, even if the system's ``/dev/random`` device uses a design that permits it to block intermittently during normal system operation. Related changes --------------- Currently, SipHash initialization and ``random`` module initialization both gather random bytes using the same code that underlies ``os.urandom``. This PEP proposes to modify these so that in situations where ``os.urandom`` would raise a ``BlockingIOError``, they automatically fall back on potentially more predictable sources of randomness. In the SipHash case, this will also print a warning message to ``stderr`` indicating that that particular Python process should not be used to process untrusted data: "Python reverted to potentially predictable hash initialization. Avoid handling untrusted data in this process.". This warning would NOT be displayed when hash randomization is explicitly disabled or set to a known value via ``PYTHONHASHSEED``. To transparently accommodate a potential future where Linux adopts the same "potentially blocking during system initialization" ``/dev/urandom`` behaviour used by other \*nix systems, this fallback source of randomness will *not* be the ``/dev/urandom`` device. Limitations on scope -------------------- No changes are proposed for Windows or Mac OS X systems, as neither of those platforms provides any mechanism to run Python code before the operating system random number generator has been initialized. Mac OS X goes so far as to kernel panic and abort the boot process if it can't properly initialize the random number generator (although Apple's restrictions on the supported hardware platforms make that exceedingly unlikely in practice). Similarly, no changes are proposed for other \*nix systems that do not offer the ``getrandom()`` syscall. On these systems, ``os.urandom()`` will continue to block waiting for the system random number generator to be initialized. While other \*nix systems that offer a non-blocking API (other than ``getrandom()``) for requesting random numbers suitable for use in security sensitive applications could potentially receive a similar update to the one proposed for ``getrandom()`` in this PEP, such changes are out of scope for this particular proposal. Python's behaviour on older versions of affected platforms that do not offer the new ``getrandom()`` syscall will also remain unchanged. Rationale ========= Raising ``BlockingIOError`` in ``os.urandom()`` on Linux -------------------------------------------------------- For several years now, the security community's guidance has been to use ``os.urandom()`` (or the ``random.SystemRandom()`` wrapper) when implementing security sensitive operations in Python. To help improve API discoverability and make it clearer that secrecy and simulation are not the same problem (even though they both involve random numbers), PEP 506 collected several of the one line recipes based on the lower level ``os.urandom()`` API into a new ``secrets`` module. However, this guidance has also come with a longstanding caveat: developers writing security sensitive software at least for Linux, and potentially for some other \*BSD systems, may need to wait until the operating system's random number generator is ready before relying on it for security sensitive operations. This generally only occurs if ``os.urandom()`` is read very early in the system initialization process, or on systems with few sources of available entropy (e.g. some kinds of virtualized or embedded systems), but unfortunately the exact conditions that trigger this are difficult to predict, and when it occurs then there is no direct way for userspace to tell it has happened without querying operating system specific interfaces. On \*BSD systems (if the particular \*BSD variant allows the problem to occur at all) and potentially also Solaris and Illumos, encountering this situation means ``os.urandom()`` will either block waiting for the system random number generator to be ready (the associated symptom would be for the affected script to pause unexpectedly on the first call to ``os.urandom()``) or else will behave the same way as it does on Linux. On Linux, in Python versions up to and including Python 3.4, and in Python 3.5 maintenance versions following Python 3.5.2, there's no clear indicator to developers that their software may not be working as expected when run early in the Linux boot process, or on hardware without good sources of entropy to seed the operating system's random number generator: due to the behaviour of the underlying ``/dev/urandom`` device, ``os.urandom()`` on Linux returns a result either way, and it takes extensive statistical analysis to show that a security vulnerability exists. By contrast, if ``BlockingIOError`` is raised in those situations, then developers using Python 3.6+ can easily choose their desired behaviour: 1. Wait for the system RNG at or before application startup (security sensitive) 2. Switch to using the random module (non-security sensitive) Adding ``secrets.wait_for_system_rng()`` ---------------------------------------- Earlier versions of this PEP proposed a number of recipes for wrapping ``os.urandom()`` to make it suitable for use in security sensitive use cases. Discussion of the proposal on the security-sig mailing list prompted the realization [9]_ that the core assumption driving the API design in this PEP was that choosing between letting the exception cause the application to fail, blocking waiting for the system RNG to be ready and switching to using the ``random`` module instead of ``os.urandom`` is an application and use-case specific decision that should take into account application and use-case specific details. There is no way for the interpreter runtime or support libraries to determine whether a particular use case is security sensitive or not, and while it's straightforward for application developer to decide how to handle an exception thrown by a particular API, they can't readily workaround an API blocking when they expected it to be non-blocking. Accordingly, the PEP was updated to add ``secrets.wait_for_system_rng()`` as an API for applications, scripts and frameworks to use to indicate that they wanted to ensure the system RNG was available before continuing, while library developers could continue to call ``os.urandom()`` without worrying that it might unexpectedly start blocking waiting for the system RNG to be available. Issuing a warning for potentially predictable internal hash initialization -------------------------------------------------------------------------- The challenge for internal hash initialization is that it might be very important to initialize SipHash with a reliably unpredictable random seed (for processes that are exposed to potentially hostile input) or it might be totally unimportant (for processes that never have to deal with untrusted data). The Python runtime has no way to know which case a given invocation involves, which means that if we allow SipHash initialization to block or error out, then our intended security enhancement may break code that is already safe and working fine, which is unacceptable -- especially since we are reasonably confident that most Python invocations that might run during Linux system initialization fall into this category (exposure to untrusted input tends to involve network access, which typically isn't brought up until after the system random number generator is initialized). However, at the same time, since Python has no way to know whether any given invocation needs to handle untrusted data, when the default SipHash initialization fails this *might* indicate a genuine security problem, which should not be allowed to pass silently. Accordingly, if internal hash initialization needs to fall back to a potentially predictable seed due to the system random number generator not being ready, it will also emit a warning message on ``stderr`` to say that the system random number generator is not available and that processing potentially hostile untrusted data should be avoided. Allowing potentially predictable ``random`` module initialization ----------------------------------------------------------------- Other than for ``random.SystemRandom`` (which is a relatively thin wrapper around ``os.urandom``), the ``random`` module has long documented that the numbers it generates are not suitable for use in security sensitive operations. Instead, the use of the system random number generator to seed the default Mersenne Twister instance is primarily aimed at ensuring Python isn't biased towards any particular starting states for simulation use cases. However, this seeding approach has also turned out to be beneficial as a harm mitigation measure for code that is using the ``random`` module inappropriately. Since a single call to ``os.urandom()`` is cheap once the system random number generator has been initialized it makes sense to retain that as the default behaviour, but there's no need to issue a warning when falling back to a potentially more predictable alternative when necessary (in such cases, a warning will typically already have been issued as part of interpreter startup, as the only way for the call when importing the random module to fail without the implicit call during interpreter startup also failing if for the latter to have been skipped by entirely disabling the hash randomization mechanism). Backwards Compatibility Impact Assessment ========================================= Similar to PEP 476, this is a proposal to turn a previously silent security failure into a noisy exception that requires the application developer to make an explicit decision regarding the behaviour they desire. As no changes are proposed for operating systems that don't provide the ``getrandom()`` syscall, ``os.urandom()`` retains its existing behaviour as a nominally blocking API that is non-blocking in practice due to the difficulty of scheduling Python code to run before the operating system random number generator is ready. We believe it may be possible to encounter problems akin to those described in this PEP on at least some \*BSD variants, but nobody has explicitly demonstrated that. On Mac OS X and Windows, it appears to be straight up impossible to even try to run a Python interpreter that early in the boot process. On Linux and other platforms with similar ``/dev/urandom`` behaviour, ``os.urandom()`` retains its status as a guaranteed non-blocking API. However, the means of achieving that status changes in the specific case of the operating system random number generator not being ready for use in security sensitive operations: historically it would return potentially predictable random data, with this PEP it would change to raise ``BlockingIOError``. Developers of affected applications would then be required to make one of the following changes to gain forward compatibility with Python 3.6, based on the kind of application they're developing. Unaffected Applications ----------------------- The following kinds of applications would be entirely unaffected by the change, regardless of whether or not they perform security sensitive operations: - applications that don't support Linux - applications that are only run on desktops or conventional servers - applications that are only run after the system RNG is ready Applications in this category simply won't encounter the new exception, so it will be reasonable for developers to wait and see if they receive Python 3.6 compatibility bugs related to the new runtime behaviour, rather than attempting to pre-emptively determine whether or not they're affected. Affected security sensitive applications ---------------------------------------- Security sensitive applications would need to either change their system configuration so the application is only started after the operating system random number generator is ready for security sensitive operations, or else change the application startup code to invoke ``secrets.wait_for_system_rng()`` As an example for components started via a systemd unit file, the following snippet would delay activation until the system RNG was ready: ExecStartPre=python3 -c "import secrets; secrets.wait_for_system_rng()" Affected non-security sensitive applications -------------------------------------------- Non-security sensitive applications should be updated to use the ``random`` module rather than ``os.urandom``:: def pseudorandom_bytes(num_bytes): return random.getrandbits(num_bytes*8).to_bytes(num_bytes, "little") Depending on the details of the application, the random module may offer other APIs that can be used directly, rather than needing to emulate the raw byte sequence produced by the ``os.urandom()`` API. Additional Background ===================== Why propose this now? --------------------- The main reason is because the Python 3.5.0 release switched to using the new Linux ``getrandom()`` syscall when available in order to avoid consuming a file descriptor [1]_, and this had the side effect of making the following operations block waiting for the system random number generator to be ready: * ``os.urandom`` (and APIs that depend on it) * importing the ``random`` module * initializing the randomized hash algorithm used by some builtin types While the first of those behaviours is arguably desirable (and consistent with the existing behaviour of ``os.urandom`` on other operating systems), the latter two behaviours are unnecessary and undesirable, and the last one is now known to cause a system level deadlock when attempting to run Python scripts during the Linux init process with Python 3.5.0 or 3.5.1 [2]_, while the second one can cause problems when using virtual machines without robust entropy sources configured [3]_. Since decoupling these behaviours in CPython will involve a number of implementation changes more appropriate for a feature release than a maintenance release, the relatively simple resolution applied in Python 3.5.2 was to revert all three of them to a behaviour similar to that of previous Python versions: if the new Linux syscall indicates it will block, then Python 3.5.2 will implicitly fall back on reading ``/dev/urandom`` directly [4]_. However, this bug report *also* resulted in a range of proposals to add *new* APIs like ``os.getrandom()`` [5]_, ``os.urandom_block()`` [6]_, ``os.pseudorandom()`` and ``os.cryptorandom()`` [7]_, or adding new optional parameters to ``os.urandom()`` itself [8]_, and then attempting to educate users on when they should call those APIs instead of just using a plain ``os.urandom()`` call. These proposals arguably represent overreactions, as the question of reliably obtaining random numbers suitable for security sensitive work on Linux is a relatively obscure problem of interest mainly to operating system developers and embedded systems programmers, that may not justify expanding the Python standard library's cross-platform APIs with new Linux-specific concerns. This is especially so with the ``secrets`` module already being added as the "use this and don't worry about the low level details" option for developers writing security sensitive software that for some reason can't rely on even higher level domain specific APIs (like web frameworks) and also don't need to worry about Python versions prior to Python 3.6. That said, it's also the case that low cost ARM devices are becoming increasingly prevalent, with a lot of them running Linux, and a lot of folks writing Python applications that run on those devices. That creates an opportunity to take an obscure security problem that currently requires a lot of knowledge about Linux boot processes and provably unpredictable random number generation to diagnose and resolve, and instead turn it into a relatively mundane and easy-to-find-in-an-internet-search runtime exception. The cross-platform behaviour of ``os.urandom()`` ------------------------------------------------ On operating systems other than Linux and NetBSD, ``os.urandom()`` may already block waiting for the operating system's random number generator to be ready. This will happen at most once in the lifetime of the process, and the call is subsequently guaranteed to be non-blocking. Linux and NetBSD are outliers in that, even when the operating system's random number generator doesn't consider itself ready for use in security sensitive operations, reading from the ``/dev/urandom`` device will return random values based on the entropy it has available. This behaviour is potentially problematic, so Linux 3.17 added a new ``getrandom()`` syscall that (amongst other benefits) allows callers to either block waiting for the random number generator to be ready, or else request an error return if the random number generator is not ready. Notably, the new API does *not* support the old behaviour of returning data that is not suitable for security sensitive use cases. Versions of Python prior up to and including Python 3.4 access the Linux ``/dev/urandom`` device directly. Python 3.5.0 and 3.5.1 (when build on a system that offered the new syscall) called ``getrandom()`` in blocking mode in order to avoid the use of a file descriptor to access ``/dev/urandom``. While there were no specific problems reported due to ``os.urandom()`` blocking in user code, there *were* problems due to CPython implicitly invoking the blocking behaviour during interpreter startup and when importing the ``random`` module. Rather than trying to decouple SipHash initialization from the ``os.urandom()`` implementation, Python 3.5.2 switched to calling ``getrandom()`` in non-blocking mode, and falling back to reading from ``/dev/urandom`` if the syscall indicates it will block. As a result of the above, ``os.urandom()`` in all Python versions up to and including Python 3.5 propagate the behaviour of the underling ``/dev/urandom`` device to Python code. Problems with the behaviour of ``/dev/urandom`` on Linux -------------------------------------------------------- The Python ``os`` module has largely co-evolved with Linux APIs, so having ``os`` module functions closely follow the behaviour of their Linux operating system level counterparts when running on Linux is typically considered to be a desirable feature. However, ``/dev/urandom`` represents a case where the current behaviour is acknowledged to be problematic, but fixing it unilaterally at the kernel level has been shown to prevent some Linux distributions from booting (at least in part due to components like Python currently using it for non-security-sensitive purposes early in the system initialization process). As an analogy, consider the following two functions:: def generate_example_password(): """Generates passwords solely for use in code examples""" return generate_unpredictable_password() def generate_actual_password(): """Generates actual passwords for use in real applications""" return generate_unpredictable_password() If you think of an operating system's random number generator as a method for generating unpredictable, secret passwords, then you can think of Linux's ``/dev/urandom`` as being implemented like:: # Oversimplified artist's conception of the kernel code # implementing /dev/urandom def generate_unpredictable_password(): if system_rng_is_ready: return use_system_rng_to_generate_password() else: # we can't make an unpredictable password; silently return a # potentially predictable one instead: return "p4ssw0rd" In this scenario, the author of ``generate_example_password`` is fine - even if ``"p4ssw0rd"`` shows up a bit more often than they expect, it's only used in examples anyway. However, the author of ``generate_actual_password`` has a problem - how do they prove that their calls to ``generate_unpredictable_password`` never follow the path that returns a predictable answer? In real life it's slightly more complicated than this, because there might be some level of system entropy available -- so the fallback might be more like ``return random.choice(["p4ssword", "passw0rd", "p4ssw0rd"])`` or something even more variable and hence only statistically predictable with better odds than the author of ``generate_actual_password`` was expecting. This doesn't really make things more provably secure, though; mostly it just means that if you try to catch the problem in the obvious way -- ``if returned_password == "p4ssw0rd": raise UhOh`` -- then it doesn't work, because ``returned_password`` might instead be ``p4ssword`` or even ``pa55word``, or just an arbitrary 64 bit sequence selected from fewer than 2**64 possibilities. So this rough sketch does give the right general idea of the consequences of the "more predictable than expected" fallback behaviour, even though it's thoroughly unfair to the Linux kernel team's efforts to mitigate the practical consequences of this problem without resorting to breaking backwards compatibility. This design is generally agreed to be a bad idea. As far as we can tell, there are no use cases whatsoever in which this is the behavior you actually want. It has led to the use of insecure ``ssh`` keys on real systems, and many \*nix-like systems (including at least Mac OS X, OpenBSD, and FreeBSD) have modified their ``/dev/urandom`` implementations so that they never return predictable outputs, either by making reads block in this case, or by simply refusing to run any userspace programs until the system RNG has been initialized. Unfortunately, Linux has so far been unable to follow suit, because it's been empirically determined that enabling the blocking behavior causes some currently extant distributions to fail to boot. Instead, the new ``getrandom()`` syscall was introduced, making it *possible* for userspace applications to access the system random number generator safely, without introducing hard to debug deadlock problems into the system initialization processes of existing Linux distros. Consequences of ``getrandom()`` availability for Python ------------------------------------------------------- Prior to the introduction of the ``getrandom()`` syscall, it simply wasn't feasible to access the Linux system random number generator in a provably safe way, so we were forced to settle for reading from ``/dev/urandom`` as the best available option. However, with ``getrandom()`` insisting on raising an error or blocking rather than returning predictable data, as well as having other advantages, it is now the recommended method for accessing the kernel RNG on Linux, with reading ``/dev/urandom`` directly relegated to "legacy" status. This moves Linux into the same category as other operating systems like Windows, which doesn't provide a ``/dev/urandom`` device at all: the best available option for implementing ``os.urandom()`` is no longer simply reading bytes from the ``/dev/urandom`` device. This means that what used to be somebody else's problem (the Linux kernel development team's) is now Python's problem -- given a way to detect that the system RNG is not initialized, we have to choose how to handle this situation whenever we try to use the system RNG. It could simply block, as was somewhat inadvertently implemented in 3.5.0, and as is proposed in Victor Stinner's competing PEP:: # artist's impression of the CPython 3.5.0-3.5.1 behavior def generate_unpredictable_bytes_or_block(num_bytes): while not system_rng_is_ready: wait return unpredictable_bytes(num_bytes) Or it could raise an error, as this PEP proposes (in *some* cases):: # artist's impression of the behavior proposed in this PEP def generate_unpredictable_bytes_or_raise(num_bytes): if system_rng_is_ready: return unpredictable_bytes(num_bytes) else: raise BlockingIOError Or it could explicitly emulate the ``/dev/urandom`` fallback behavior, as was implemented in 3.5.2rc1 and is expected to remain for the rest of the 3.5.x cycle:: # artist's impression of the CPython 3.5.2rc1+ behavior def generate_unpredictable_bytes_or_maybe_not(num_bytes): if system_rng_is_ready: return unpredictable_bytes(num_bytes) else: return (b"p4ssw0rd" * (num_bytes // 8 + 1))[:num_bytes] (And the same caveats apply to this sketch as applied to the ``generate_unpredictable_password`` sketch of ``/dev/urandom`` above.) There are five places where CPython and the standard library attempt to use the operating system's random number generator, and thus five places where this decision has to be made: * initializing the SipHash used to protect ``str.__hash__`` and friends against DoS attacks (called unconditionally at startup) * initializing the ``random`` module (called when ``random`` is imported) * servicing user calls to the ``os.urandom`` public API * the higher level ``random.SystemRandom`` public API * the new ``secrets`` module public API added by PEP 506 Currently, these five places all use the same underlying code, and thus make this decision in the same way. This whole problem was first noticed because 3.5.0 switched that underlying code to the ``generate_unpredictable_bytes_or_block`` behavior, and it turns out that there are some rare cases where Linux boot scripts attempted to run a Python program as part of system initialization, the Python startup sequence blocked while trying to initialize SipHash, and then this triggered a deadlock because the system stopped doing anything -- including gathering new entropy -- until the Python script was forcibly terminated by an external timer. This is particularly unfortunate since the scripts in question never processed untrusted input, so there was no need for SipHash to be initialized with provably unpredictable random data in the first place. This motivated the change in 3.5.2rc1 to emulate the old ``/dev/urandom`` behavior in all cases (by calling ``getrandom()`` in non-blocking mode, and then falling back to reading ``/dev/urandom`` if the syscall indicates that the ``/dev/urandom`` pool is not yet fully initialized.) We don't know whether such problems may also exist in the Fedora/RHEL/CentOS ecosystem, as the build systems for those distributions use chroots on servers running an older operating system kernel that doesn't offer the ``getrandom()`` syscall, which means CPython's current build configuration compiles out the runtime check for that syscall [10]_. A similar problem was found due to the ``random`` module calling ``os.urandom`` as a side-effect of import in order to seed the default global ``random.Random()`` instance. We have not received any specific complaints regarding direct calls to ``os.urandom()`` or ``random.SystemRandom()`` blocking with 3.5.0 or 3.5.1 - only problem reports due to the implicit blocking on interpreter startup and as a side-effect of importing the random module. Accordingly, this PEP proposes providing consistent shared behaviour for the latter three cases (ensuring that their behaviour is unequivocally suitable for all security sensitive operations), while updating the first two cases to account for that behavioural change. This approach should mean that the vast majority of Python users never need to even be aware that this change was made, while those few whom it affects will receive an exception at runtime that they can look up online and find suitable guidance on addressing. References ========== .. [1] os.urandom() should use Linux 3.17 getrandom() syscall (http://bugs.python.org/issue22181) .. [2] Python 3.5 running on Linux kernel 3.17+ can block at startup or on importing the random module on getrandom() (http://bugs.python.org/issue26839) .. [3] "import random" blocks on entropy collection on Linux with low entropy (http://bugs.python.org/issue25420) .. [4] os.urandom() doesn't block on Linux anymore (https://hg.python.org/cpython/rev/9de508dc4837) .. [5] Proposal to add os.getrandom() (http://bugs.python.org/issue26839#msg267803) .. [6] Add os.urandom_block() (http://bugs.python.org/issue27250) .. [7] Add random.cryptorandom() and random.pseudorandom, deprecate os.urandom() (http://bugs.python.org/issue27279) .. [8] Always use getrandom() in os.random() on Linux and add block=False parameter to os.urandom() (http://bugs.python.org/issue27266) .. [9] Application level vs library level design decisions (https://mail.python.org/pipermail/security-sig/2016-June/000057.html) .. [10] Does the HAVE_GETRANDOM_SYSCALL config setting make sense? (https://mail.python.org/pipermail/security-sig/2016-June/000060.html) For additional background details beyond those captured in this PEP and Victor's competing PEP, also see Victor's prior collection of relevant information and links at https://haypo-notes.readthedocs.io/summary_python_random_issue.html Copyright ========= This document has been placed into the public domain. -- Nick Coghlan | ncoghlan(a)gmail.com | Brisbane, Australia

1 0

getrandom() syscalls and Python runtime binary portability
by Nick Coghlan 25 Jun '16

25 Jun '16

Hi folks, Working on an update to PEP 522, I realised while poking around in sysconfig for the HAVE_GETRANDOM_SYSCALL flag that only checking for whether or not the syscall had been available at buildtime would be potentially problematic - it means that a Python built against a newer Linux kernel (e.g. Ubuntu 16.04, Fedora 24) may do the wrong thing when run on an older kernel that hasn't had the new syscall backported (e.g. Ubuntu 14.04, RHEL 7.2, CentOS 7.1511). That's something that can easily happen with containers, or any other case of bundling the language runtime with the application executable. The actual code behind os.urandom already deals with this case correctly (see the ENOSYS reference in py_getrandom at [1]), but it means there really is no way for pure Python code running against an older kernel to tell whether a successful os.urandom() call was because the system RNG was ready or because the kernel is old. So regardless of whether we go with the blocking-by-default or raise-BlockingIOError strategy, we should also define what we want the interpreter to do in the ENOSYS case (for PEP 522, I wanted to warn about it in the new secrets.wait_for_system_rng() function, but at least for now I'm going to settle for letting the SipHash initialisation warn about it, the same way it would for a lack of entropy) This is actually the best argument I've seen so far for exposing os.getrandom() directly: unlike os.urandom(), we could allow a new os.getrandom() API to raise NotImplementedError if the running kernel doesn't provide the getrandom() syscall. Having such an API available would then let secrets.wait_for_system_rng() more reliably check whether or not the system RNG was ready before falling back on a potentially blocking read of /dev/random. Cheers, Nick. [1] https://hg.python.org/cpython/file/default/Python/random.c#l119 -- Nick Coghlan | ncoghlan(a)gmail.com | Brisbane, Australia

1 0