LCOV - code coverage report
Current view: | top level - Python - bootstrap_hash.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 40 | 125 | 32.0 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 6 | 9 | 66.7 %
|  |  | Branches: | 14 | 90 | 15.6 %

               Branch data     Line data    Source code
           1                 :            : #include "Python.h"
           2                 :            : #include "pycore_initconfig.h"
           3                 :            : #include "pycore_fileutils.h"     // _Py_fstat_noraise()
           4                 :            : #include "pycore_runtime.h"       // _PyRuntime
           5                 :            :
           6                 :            : #ifdef MS_WINDOWS
           7                 :            : #  include <windows.h>
           8                 :            : #  include <bcrypt.h>
           9                 :            : #else
          10                 :            : #  include <fcntl.h>
          11                 :            : #  ifdef HAVE_SYS_STAT_H
          12                 :            : #    include <sys/stat.h>
          13                 :            : #  endif
          14                 :            : #  ifdef HAVE_LINUX_RANDOM_H
          15                 :            : #    include <linux/random.h>
          16                 :            : #  endif
          17                 :            : #  if defined(HAVE_SYS_RANDOM_H) && (defined(HAVE_GETRANDOM) || defined(HAVE_GETENTROPY))
          18                 :            : #    include <sys/random.h>
          19                 :            : #  endif
          20                 :            : #  if !defined(HAVE_GETRANDOM) && defined(HAVE_GETRANDOM_SYSCALL)
          21                 :            : #    include <sys/syscall.h>
          22                 :            : #  endif
          23                 :            : #endif
          24                 :            :
          25                 :            : #ifdef _Py_MEMORY_SANITIZER
          26                 :            : #  include <sanitizer/msan_interface.h>
          27                 :            : #endif
          28                 :            :
          29                 :            : #if defined(__APPLE__) && defined(__has_builtin)
          30                 :            : #  if __has_builtin(__builtin_available)
          31                 :            : #    define HAVE_GETENTRYPY_GETRANDOM_RUNTIME __builtin_available(macOS 10.12, iOS 10.10, tvOS 10.0, watchOS 3.0, *)
          32                 :            : #  endif
          33                 :            : #endif
          34                 :            : #ifndef HAVE_GETENTRYPY_GETRANDOM_RUNTIME
          35                 :            : #  define HAVE_GETENTRYPY_GETRANDOM_RUNTIME 1
          36                 :            : #endif
          37                 :            :
          38                 :            :
          39                 :            : #ifdef Py_DEBUG
          40                 :            : int _Py_HashSecret_Initialized = 0;
          41                 :            : #else
          42                 :            : static int _Py_HashSecret_Initialized = 0;
          43                 :            : #endif
          44                 :            :
          45                 :            : #ifdef MS_WINDOWS
          46                 :            :
          47                 :            : /* Fill buffer with size pseudo-random bytes generated by the Windows CryptoGen
          48                 :            :    API. Return 0 on success, or raise an exception and return -1 on error. */
          49                 :            : static int
          50                 :            : win32_urandom(unsigned char *buffer, Py_ssize_t size, int raise)
          51                 :            : {
          52                 :            :     while (size > 0)
          53                 :            :     {
          54                 :            :         DWORD chunk = (DWORD)Py_MIN(size, PY_DWORD_MAX);
          55                 :            :         NTSTATUS status = BCryptGenRandom(NULL, buffer, chunk, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
          56                 :            :         if (!BCRYPT_SUCCESS(status)) {
          57                 :            :             /* BCryptGenRandom() failed */
          58                 :            :             if (raise) {
          59                 :            :                 PyErr_SetFromWindowsErr(0);
          60                 :            :             }
          61                 :            :             return -1;
          62                 :            :         }
          63                 :            :         buffer += chunk;
          64                 :            :         size -= chunk;
          65                 :            :     }
          66                 :            :     return 0;
          67                 :            : }
          68                 :            :
          69                 :            : #else /* !MS_WINDOWS */
          70                 :            :
          71                 :            : #if defined(HAVE_GETRANDOM) || defined(HAVE_GETRANDOM_SYSCALL)
          72                 :            : #define PY_GETRANDOM 1
          73                 :            :
          74                 :            : /* Call getrandom() to get random bytes:
          75                 :            :
          76                 :            :    - Return 1 on success
          77                 :            :    - Return 0 if getrandom() is not available (failed with ENOSYS or EPERM),
          78                 :            :      or if getrandom(GRND_NONBLOCK) failed with EAGAIN (system urandom not
          79                 :            :      initialized yet) and raise=0.
          80                 :            :    - Raise an exception (if raise is non-zero) and return -1 on error:
          81                 :            :      if getrandom() failed with EINTR, raise is non-zero and the Python signal
          82                 :            :      handler raised an exception, or if getrandom() failed with a different
          83                 :            :      error.
          84                 :            :
          85                 :            :    getrandom() is retried if it failed with EINTR: interrupted by a signal. */
          86                 :            : static int
          87                 :         30 : py_getrandom(void *buffer, Py_ssize_t size, int blocking, int raise)
          88                 :            : {
          89                 :            :     /* Is getrandom() supported by the running kernel? Set to 0 if getrandom()
          90                 :            :        failed with ENOSYS or EPERM. Need Linux kernel 3.17 or newer, or Solaris
          91                 :            :        11.3 or newer */
          92                 :            :     static int getrandom_works = 1;
          93                 :            :     int flags;
          94                 :            :     char *dest;
          95                 :            :     long n;
          96                 :            :
          97         [ -  + ]:         30 :     if (!getrandom_works) {
          98                 :          0 :         return 0;
          99                 :            :     }
         100                 :            :
         101                 :         30 :     flags = blocking ? 0 : GRND_NONBLOCK;
         102                 :         30 :     dest = buffer;
         103         [ +  + ]:         60 :     while (0 < size) {
         104                 :            : #if defined(__sun) && defined(__SVR4)
         105                 :            :         /* Issue #26735: On Solaris, getrandom() is limited to returning up
         106                 :            :            to 1024 bytes. Call it multiple times if more bytes are
         107                 :            :            requested. */
         108                 :            :         n = Py_MIN(size, 1024);
         109                 :            : #else
         110                 :         30 :         n = Py_MIN(size, LONG_MAX);
         111                 :            : #endif
         112                 :            :
         113                 :         30 :         errno = 0;
         114                 :            : #ifdef HAVE_GETRANDOM
         115         [ +  + ]:         30 :         if (raise) {
         116                 :          1 :             Py_BEGIN_ALLOW_THREADS
         117                 :          1 :             n = getrandom(dest, n, flags);
         118                 :          1 :             Py_END_ALLOW_THREADS
         119                 :            :         }
         120                 :            :         else {
         121                 :         29 :             n = getrandom(dest, n, flags);
         122                 :            :         }
         123                 :            : #else
         124                 :            :         /* On Linux, use the syscall() function because the GNU libc doesn't
         125                 :            :            expose the Linux getrandom() syscall yet. See:
         126                 :            :            https://sourceware.org/bugzilla/show_bug.cgi?id=17252 */
         127                 :            :         if (raise) {
         128                 :            :             Py_BEGIN_ALLOW_THREADS
         129                 :            :             n = syscall(SYS_getrandom, dest, n, flags);
         130                 :            :             Py_END_ALLOW_THREADS
         131                 :            :         }
         132                 :            :         else {
         133                 :            :             n = syscall(SYS_getrandom, dest, n, flags);
         134                 :            :         }
         135                 :            : #  ifdef _Py_MEMORY_SANITIZER
         136                 :            :         if (n > 0) {
         137                 :            :              __msan_unpoison(dest, n);
         138                 :            :         }
         139                 :            : #  endif
         140                 :            : #endif
         141                 :            :
         142         [ -  + ]:         30 :         if (n < 0) {
         143                 :            :             /* ENOSYS: the syscall is not supported by the kernel.
         144                 :            :                EPERM: the syscall is blocked by a security policy (ex: SECCOMP)
         145                 :            :                or something else. */
         146   [ #  #  #  # ]:          0 :             if (errno == ENOSYS || errno == EPERM) {
         147                 :          0 :                 getrandom_works = 0;
         148                 :          0 :                 return 0;
         149                 :            :             }
         150                 :            :
         151                 :            :             /* getrandom(GRND_NONBLOCK) fails with EAGAIN if the system urandom
         152                 :            :                is not initialized yet. For _PyRandom_Init(), we ignore the
         153                 :            :                error and fall back on reading /dev/urandom which never blocks,
         154                 :            :                even if the system urandom is not initialized yet:
         155                 :            :                see the PEP 524. */
         156   [ #  #  #  #  :          0 :             if (errno == EAGAIN && !raise && !blocking) {
                       #  # ]
         157                 :          0 :                 return 0;
         158                 :            :             }
         159                 :            :
         160         [ #  # ]:          0 :             if (errno == EINTR) {
         161         [ #  # ]:          0 :                 if (raise) {
         162         [ #  # ]:          0 :                     if (PyErr_CheckSignals()) {
         163                 :          0 :                         return -1;
         164                 :            :                     }
         165                 :            :                 }
         166                 :            :
         167                 :            :                 /* retry getrandom() if it was interrupted by a signal */
         168                 :          0 :                 continue;
         169                 :            :             }
         170                 :            :
         171         [ #  # ]:          0 :             if (raise) {
         172                 :          0 :                 PyErr_SetFromErrno(PyExc_OSError);
         173                 :            :             }
         174                 :          0 :             return -1;
         175                 :            :         }
         176                 :            :
         177                 :         30 :         dest += n;
         178                 :         30 :         size -= n;
         179                 :            :     }
         180                 :         30 :     return 1;
         181                 :            : }
         182                 :            :
         183                 :            : #elif defined(HAVE_GETENTROPY)
         184                 :            : #define PY_GETENTROPY 1
         185                 :            :
         186                 :            : /* Fill buffer with size pseudo-random bytes generated by getentropy():
         187                 :            :
         188                 :            :    - Return 1 on success
         189                 :            :    - Return 0 if getentropy() syscall is not available (failed with ENOSYS or
         190                 :            :      EPERM).
         191                 :            :    - Raise an exception (if raise is non-zero) and return -1 on error:
         192                 :            :      if getentropy() failed with EINTR, raise is non-zero and the Python signal
         193                 :            :      handler raised an exception, or if getentropy() failed with a different
         194                 :            :      error.
         195                 :            :
         196                 :            :    getentropy() is retried if it failed with EINTR: interrupted by a signal. */
         197                 :            :
         198                 :            : #if defined(__APPLE__) && defined(__has_attribute) && __has_attribute(availability)
         199                 :            : static int
         200                 :            : py_getentropy(char *buffer, Py_ssize_t size, int raise)
         201                 :            :         __attribute__((availability(macos,introduced=10.12)))
         202                 :            :         __attribute__((availability(ios,introduced=10.0)))
         203                 :            :         __attribute__((availability(tvos,introduced=10.0)))
         204                 :            :         __attribute__((availability(watchos,introduced=3.0)));
         205                 :            : #endif
         206                 :            :
         207                 :            : static int
         208                 :            : py_getentropy(char *buffer, Py_ssize_t size, int raise)
         209                 :            : {
         210                 :            :     /* Is getentropy() supported by the running kernel? Set to 0 if
         211                 :            :        getentropy() failed with ENOSYS or EPERM. */
         212                 :            :     static int getentropy_works = 1;
         213                 :            :
         214                 :            :     if (!getentropy_works) {
         215                 :            :         return 0;
         216                 :            :     }
         217                 :            :
         218                 :            :     while (size > 0) {
         219                 :            :         /* getentropy() is limited to returning up to 256 bytes. Call it
         220                 :            :            multiple times if more bytes are requested. */
         221                 :            :         Py_ssize_t len = Py_MIN(size, 256);
         222                 :            :         int res;
         223                 :            :
         224                 :            :         if (raise) {
         225                 :            :             Py_BEGIN_ALLOW_THREADS
         226                 :            :             res = getentropy(buffer, len);
         227                 :            :             Py_END_ALLOW_THREADS
         228                 :            :         }
         229                 :            :         else {
         230                 :            :             res = getentropy(buffer, len);
         231                 :            :         }
         232                 :            :
         233                 :            :         if (res < 0) {
         234                 :            :             /* ENOSYS: the syscall is not supported by the running kernel.
         235                 :            :                EPERM: the syscall is blocked by a security policy (ex: SECCOMP)
         236                 :            :                or something else. */
         237                 :            :             if (errno == ENOSYS || errno == EPERM) {
         238                 :            :                 getentropy_works = 0;
         239                 :            :                 return 0;
         240                 :            :             }
         241                 :            :
         242                 :            :             if (errno == EINTR) {
         243                 :            :                 if (raise) {
         244                 :            :                     if (PyErr_CheckSignals()) {
         245                 :            :                         return -1;
         246                 :            :                     }
         247                 :            :                 }
         248                 :            :
         249                 :            :                 /* retry getentropy() if it was interrupted by a signal */
         250                 :            :                 continue;
         251                 :            :             }
         252                 :            :
         253                 :            :             if (raise) {
         254                 :            :                 PyErr_SetFromErrno(PyExc_OSError);
         255                 :            :             }
         256                 :            :             return -1;
         257                 :            :         }
         258                 :            :
         259                 :            :         buffer += len;
         260                 :            :         size -= len;
         261                 :            :     }
         262                 :            :     return 1;
         263                 :            : }
         264                 :            : #endif /* defined(HAVE_GETENTROPY) && !(defined(__sun) && defined(__SVR4)) */
         265                 :            :
         266                 :            :
         267                 :            : #define urandom_cache (_PyRuntime.pyhash_state.urandom_cache)
         268                 :            :
         269                 :            : /* Read random bytes from the /dev/urandom device:
         270                 :            :
         271                 :            :    - Return 0 on success
         272                 :            :    - Raise an exception (if raise is non-zero) and return -1 on error
         273                 :            :
         274                 :            :    Possible causes of errors:
         275                 :            :
         276                 :            :    - open() failed with ENOENT, ENXIO, ENODEV, EACCES: the /dev/urandom device
         277                 :            :      was not found. For example, it was removed manually or not exposed in a
         278                 :            :      chroot or container.
         279                 :            :    - open() failed with a different error
         280                 :            :    - fstat() failed
         281                 :            :    - read() failed or returned 0
         282                 :            :
         283                 :            :    read() is retried if it failed with EINTR: interrupted by a signal.
         284                 :            :
         285                 :            :    The file descriptor of the device is kept open between calls to avoid using
         286                 :            :    many file descriptors when run in parallel from multiple threads:
         287                 :            :    see the issue #18756.
         288                 :            :
         289                 :            :    st_dev and st_ino fields of the file descriptor (from fstat()) are cached to
         290                 :            :    check if the file descriptor was replaced by a different file (which is
         291                 :            :    likely a bug in the application): see the issue #21207.
         292                 :            :
         293                 :            :    If the file descriptor was closed or replaced, open a new file descriptor
         294                 :            :    but don't close the old file descriptor: it probably points to something
         295                 :            :    important for some third-party code. */
         296                 :            : static int
         297                 :          0 : dev_urandom(char *buffer, Py_ssize_t size, int raise)
         298                 :            : {
         299                 :            :     int fd;
         300                 :            :     Py_ssize_t n;
         301                 :            :
         302         [ #  # ]:          0 :     if (raise) {
         303                 :            :         struct _Py_stat_struct st;
         304                 :            :         int fstat_result;
         305                 :            :
         306         [ #  # ]:          0 :         if (urandom_cache.fd >= 0) {
         307                 :          0 :             Py_BEGIN_ALLOW_THREADS
         308                 :          0 :             fstat_result = _Py_fstat_noraise(urandom_cache.fd, &st);
         309                 :          0 :             Py_END_ALLOW_THREADS
         310                 :            :
         311                 :            :             /* Does the fd point to the same thing as before? (issue #21207) */
         312         [ #  # ]:          0 :             if (fstat_result
         313         [ #  # ]:          0 :                 || st.st_dev != urandom_cache.st_dev
         314         [ #  # ]:          0 :                 || st.st_ino != urandom_cache.st_ino) {
         315                 :            :                 /* Something changed: forget the cached fd (but don't close it,
         316                 :            :                    since it probably points to something important for some
         317                 :            :                    third-party code). */
         318                 :          0 :                 urandom_cache.fd = -1;
         319                 :            :             }
         320                 :            :         }
         321         [ #  # ]:          0 :         if (urandom_cache.fd >= 0)
         322                 :          0 :             fd = urandom_cache.fd;
         323                 :            :         else {
         324                 :          0 :             fd = _Py_open("/dev/urandom", O_RDONLY);
         325         [ #  # ]:          0 :             if (fd < 0) {
         326   [ #  #  #  # ]:          0 :                 if (errno == ENOENT || errno == ENXIO ||
         327   [ #  #  #  # ]:          0 :                     errno == ENODEV || errno == EACCES) {
         328                 :          0 :                     PyErr_SetString(PyExc_NotImplementedError,
         329                 :            :                                     "/dev/urandom (or equivalent) not found");
         330                 :            :                 }
         331                 :            :                 /* otherwise, keep the OSError exception raised by _Py_open() */
         332                 :          0 :                 return -1;
         333                 :            :             }
         334         [ #  # ]:          0 :             if (urandom_cache.fd >= 0) {
         335                 :            :                 /* urandom_fd was initialized by another thread while we were
         336                 :            :                    not holding the GIL, keep it. */
         337                 :          0 :                 close(fd);
         338                 :          0 :                 fd = urandom_cache.fd;
         339                 :            :             }
         340                 :            :             else {
         341         [ #  # ]:          0 :                 if (_Py_fstat(fd, &st)) {
         342                 :          0 :                     close(fd);
         343                 :          0 :                     return -1;
         344                 :            :                 }
         345                 :            :                 else {
         346                 :          0 :                     urandom_cache.fd = fd;
         347                 :          0 :                     urandom_cache.st_dev = st.st_dev;
         348                 :          0 :                     urandom_cache.st_ino = st.st_ino;
         349                 :            :                 }
         350                 :            :             }
         351                 :            :         }
         352                 :            :
         353                 :            :         do {
         354                 :          0 :             n = _Py_read(fd, buffer, (size_t)size);
         355         [ #  # ]:          0 :             if (n == -1)
         356                 :          0 :                 return -1;
         357         [ #  # ]:          0 :             if (n == 0) {
         358                 :          0 :                 PyErr_Format(PyExc_RuntimeError,
         359                 :            :                         "Failed to read %zi bytes from /dev/urandom",
         360                 :            :                         size);
         361                 :          0 :                 return -1;
         362                 :            :             }
         363                 :            :
         364                 :          0 :             buffer += n;
         365                 :          0 :             size -= n;
         366         [ #  # ]:          0 :         } while (0 < size);
         367                 :            :     }
         368                 :            :     else {
         369                 :          0 :         fd = _Py_open_noraise("/dev/urandom", O_RDONLY);
         370         [ #  # ]:          0 :         if (fd < 0) {
         371                 :          0 :             return -1;
         372                 :            :         }
         373                 :            :
         374         [ #  # ]:          0 :         while (0 < size)
         375                 :            :         {
         376                 :            :             do {
         377                 :          0 :                 n = read(fd, buffer, (size_t)size);
         378   [ #  #  #  # ]:          0 :             } while (n < 0 && errno == EINTR);
         379                 :            :
         380         [ #  # ]:          0 :             if (n <= 0) {
         381                 :            :                 /* stop on error or if read(size) returned 0 */
         382                 :          0 :                 close(fd);
         383                 :          0 :                 return -1;
         384                 :            :             }
         385                 :            :
         386                 :          0 :             buffer += n;
         387                 :          0 :             size -= n;
         388                 :            :         }
         389                 :          0 :         close(fd);
         390                 :            :     }
         391                 :          0 :     return 0;
         392                 :            : }
         393                 :            :
         394                 :            : static void
         395                 :         25 : dev_urandom_close(void)
         396                 :            : {
         397         [ -  + ]:         25 :     if (urandom_cache.fd >= 0) {
         398                 :          0 :         close(urandom_cache.fd);
         399                 :          0 :         urandom_cache.fd = -1;
         400                 :            :     }
         401                 :         25 : }
         402                 :            :
         403                 :            : #undef urandom_cache
         404                 :            :
         405                 :            : #endif /* !MS_WINDOWS */
         406                 :            :
         407                 :            :
         408                 :            : /* Fill buffer with pseudo-random bytes generated by a linear congruent
         409                 :            :    generator (LCG):
         410                 :            :
         411                 :            :        x(n+1) = (x(n) * 214013 + 2531011) % 2^32
         412                 :            :
         413                 :            :    Use bits 23..16 of x(n) to generate a byte. */
         414                 :            : static void
         415                 :          0 : lcg_urandom(unsigned int x0, unsigned char *buffer, size_t size)
         416                 :            : {
         417                 :            :     size_t index;
         418                 :            :     unsigned int x;
         419                 :            :
         420                 :          0 :     x = x0;
         421         [ #  # ]:          0 :     for (index=0; index < size; index++) {
         422                 :          0 :         x *= 214013;
         423                 :          0 :         x += 2531011;
         424                 :            :         /* modulo 2 ^ (8 * sizeof(int)) */
         425                 :          0 :         buffer[index] = (x >> 16) & 0xff;
         426                 :            :     }
         427                 :          0 : }
         428                 :            :
         429                 :            : /* Read random bytes:
         430                 :            :
         431                 :            :    - Return 0 on success
         432                 :            :    - Raise an exception (if raise is non-zero) and return -1 on error
         433                 :            :
         434                 :            :    Used sources of entropy ordered by preference, preferred source first:
         435                 :            :
         436                 :            :    - BCryptGenRandom() on Windows
         437                 :            :    - getrandom() function (ex: Linux and Solaris): call py_getrandom()
         438                 :            :    - getentropy() function (ex: OpenBSD): call py_getentropy()
         439                 :            :    - /dev/urandom device
         440                 :            :
         441                 :            :    Read from the /dev/urandom device if getrandom() or getentropy() function
         442                 :            :    is not available or does not work.
         443                 :            :
         444                 :            :    Prefer getrandom() over getentropy() because getrandom() supports blocking
         445                 :            :    and non-blocking mode: see the PEP 524. Python requires non-blocking RNG at
         446                 :            :    startup to initialize its hash secret, but os.urandom() must block until the
         447                 :            :    system urandom is initialized (at least on Linux 3.17 and newer).
         448                 :            :
         449                 :            :    Prefer getrandom() and getentropy() over reading directly /dev/urandom
         450                 :            :    because these functions don't need file descriptors and so avoid ENFILE or
         451                 :            :    EMFILE errors (too many open files): see the issue #18756.
         452                 :            :
         453                 :            :    Only the getrandom() function supports non-blocking mode.
         454                 :            :
         455                 :            :    Only use RNG running in the kernel. They are more secure because it is
         456                 :            :    harder to get the internal state of a RNG running in the kernel land than a
         457                 :            :    RNG running in the user land. The kernel has a direct access to the hardware
         458                 :            :    and has access to hardware RNG, they are used as entropy sources.
         459                 :            :
         460                 :            :    Note: the OpenSSL RAND_pseudo_bytes() function does not automatically reseed
         461                 :            :    its RNG on fork(), two child processes (with the same pid) generate the same
         462                 :            :    random numbers: see issue #18747. Kernel RNGs don't have this issue,
         463                 :            :    they have access to good quality entropy sources.
         464                 :            :
         465                 :            :    If raise is zero:
         466                 :            :
         467                 :            :    - Don't raise an exception on error
         468                 :            :    - Don't call the Python signal handler (don't call PyErr_CheckSignals()) if
         469                 :            :      a function fails with EINTR: retry directly the interrupted function
         470                 :            :    - Don't release the GIL to call functions.
         471                 :            : */
         472                 :            : static int
         473                 :         30 : pyurandom(void *buffer, Py_ssize_t size, int blocking, int raise)
         474                 :            : {
         475                 :            : #if defined(PY_GETRANDOM) || defined(PY_GETENTROPY)
         476                 :            :     int res;
         477                 :            : #endif
         478                 :            :
         479         [ -  + ]:         30 :     if (size < 0) {
         480         [ #  # ]:          0 :         if (raise) {
         481                 :          0 :             PyErr_Format(PyExc_ValueError,
         482                 :            :                          "negative argument not allowed");
         483                 :            :         }
         484                 :          0 :         return -1;
         485                 :            :     }
         486                 :            :
         487         [ -  + ]:         30 :     if (size == 0) {
         488                 :          0 :         return 0;
         489                 :            :     }
         490                 :            :
         491                 :            : #ifdef MS_WINDOWS
         492                 :            :     return win32_urandom((unsigned char *)buffer, size, raise);
         493                 :            : #else
         494                 :            :
         495                 :            : #if defined(PY_GETRANDOM) || defined(PY_GETENTROPY)
         496                 :            :     if (HAVE_GETENTRYPY_GETRANDOM_RUNTIME) {
         497                 :            : #ifdef PY_GETRANDOM
         498                 :         30 :         res = py_getrandom(buffer, size, blocking, raise);
         499                 :            : #else
         500                 :            :         res = py_getentropy(buffer, size, raise);
         501                 :            : #endif
         502         [ -  + ]:         30 :         if (res < 0) {
         503                 :          0 :             return -1;
         504                 :            :         }
         505         [ +  - ]:         30 :         if (res == 1) {
         506                 :         30 :             return 0;
         507                 :            :         }
         508                 :            :         /* getrandom() or getentropy() function is not available: failed with
         509                 :            :            ENOSYS or EPERM. Fall back on reading from /dev/urandom. */
         510                 :            :         } /* end of availability block */
         511                 :            : #endif
         512                 :            :
         513                 :          0 :     return dev_urandom(buffer, size, raise);
         514                 :            : #endif
         515                 :            : }
         516                 :            :
         517                 :            : /* Fill buffer with size pseudo-random bytes from the operating system random
         518                 :            :    number generator (RNG). It is suitable for most cryptographic purposes
         519                 :            :    except long living private keys for asymmetric encryption.
         520                 :            :
         521                 :            :    On Linux 3.17 and newer, the getrandom() syscall is used in blocking mode:
         522                 :            :    block until the system urandom entropy pool is initialized (128 bits are
         523                 :            :    collected by the kernel).
         524                 :            :
         525                 :            :    Return 0 on success. Raise an exception and return -1 on error. */
         526                 :            : int
         527                 :          0 : _PyOS_URandom(void *buffer, Py_ssize_t size)
         528                 :            : {
         529                 :          0 :     return pyurandom(buffer, size, 1, 1);
         530                 :            : }
         531                 :            :
         532                 :            : /* Fill buffer with size pseudo-random bytes from the operating system random
         533                 :            :    number generator (RNG). It is not suitable for cryptographic purpose.
         534                 :            :
         535                 :            :    On Linux 3.17 and newer (when getrandom() syscall is used), if the system
         536                 :            :    urandom is not initialized yet, the function returns "weak" entropy read
         537                 :            :    from /dev/urandom.
         538                 :            :
         539                 :            :    Return 0 on success. Raise an exception and return -1 on error. */
         540                 :            : int
         541                 :          1 : _PyOS_URandomNonblock(void *buffer, Py_ssize_t size)
         542                 :            : {
         543                 :          1 :     return pyurandom(buffer, size, 0, 1);
         544                 :            : }
         545                 :            :
         546                 :            :
         547                 :            : PyStatus
         548                 :         29 : _Py_HashRandomization_Init(const PyConfig *config)
         549                 :            : {
         550                 :         29 :     void *secret = &_Py_HashSecret;
         551                 :         29 :     Py_ssize_t secret_size = sizeof(_Py_HashSecret_t);
         552                 :            :
         553         [ -  + ]:         29 :     if (_Py_HashSecret_Initialized) {
         554                 :          0 :         return _PyStatus_OK();
         555                 :            :     }
         556                 :         29 :     _Py_HashSecret_Initialized = 1;
         557                 :            :
         558         [ -  + ]:         29 :     if (config->use_hash_seed) {
         559         [ #  # ]:          0 :         if (config->hash_seed == 0) {
         560                 :            :             /* disable the randomized hash */
         561                 :          0 :             memset(secret, 0, secret_size);
         562                 :            :         }
         563                 :            :         else {
         564                 :            :             /* use the specified hash seed */
         565                 :          0 :             lcg_urandom(config->hash_seed, secret, secret_size);
         566                 :            :         }
         567                 :            :     }
         568                 :            :     else {
         569                 :            :         /* use a random hash seed */
         570                 :            :         int res;
         571                 :            :
         572                 :            :         /* _PyRandom_Init() is called very early in the Python initialization
         573                 :            :            and so exceptions cannot be used (use raise=0).
         574                 :            :
         575                 :            :            _PyRandom_Init() must not block Python initialization: call
         576                 :            :            pyurandom() is non-blocking mode (blocking=0): see the PEP 524. */
         577                 :         29 :         res = pyurandom(secret, secret_size, 0, 0);
         578         [ -  + ]:         29 :         if (res < 0) {
         579                 :          0 :             return _PyStatus_ERR("failed to get random numbers "
         580                 :            :                                  "to initialize Python");
         581                 :            :         }
         582                 :            :     }
         583                 :         29 :     return _PyStatus_OK();
         584                 :            : }
         585                 :            :
         586                 :            :
         587                 :            : void
         588                 :         25 : _Py_HashRandomization_Fini(void)
         589                 :            : {
         590                 :            : #ifndef MS_WINDOWS
         591                 :         25 :     dev_urandom_close();
         592                 :            : #endif
         593                 :         25 : }

Generated by: LCOV version 1.14