www.aleph1.co.uk Git - yaffs-website/blob - vendor/paragonie/random_compat/lib/random_bytes_dev_urandom.php

   1 <?php
   2 /**
   3  * Random_* Compatibility Library
   4  * for using the new PHP 7 random_* API in PHP 5 projects
   5  *
   6  * The MIT License (MIT)
   7  *
   8  * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 if (!defined('RANDOM_COMPAT_READ_BUFFER')) {
  30     define('RANDOM_COMPAT_READ_BUFFER', 8);
  31 }
  32
  33 if (!is_callable('random_bytes')) {
  34     /**
  35      * Unless open_basedir is enabled, use /dev/urandom for
  36      * random numbers in accordance with best practices
  37      *
  38      * Why we use /dev/urandom and not /dev/random
  39      * @ref http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers
  40      *
  41      * @param int $bytes
  42      *
  43      * @throws Exception
  44      *
  45      * @return string
  46      */
  47     function random_bytes($bytes)
  48     {
  49         /** @var resource $fp */
  50         static $fp = null;
  51
  52         /**
  53          * This block should only be run once
  54          */
  55         if (empty($fp)) {
  56             /**
  57              * We use /dev/urandom if it is a char device.
  58              * We never fall back to /dev/random
  59              */
  60             /** @var resource|bool $fp */
  61             $fp = fopen('/dev/urandom', 'rb');
  62             if (is_resource($fp)) {
  63                 /** @var array<string, int> $st */
  64                 $st = fstat($fp);
  65                 if (($st['mode'] & 0170000) !== 020000) {
  66                     fclose($fp);
  67                     $fp = false;
  68                 }
  69             }
  70
  71             if (is_resource($fp)) {
  72                 /**
  73                  * stream_set_read_buffer() does not exist in HHVM
  74                  *
  75                  * If we don't set the stream's read buffer to 0, PHP will
  76                  * internally buffer 8192 bytes, which can waste entropy
  77                  *
  78                  * stream_set_read_buffer returns 0 on success
  79                  */
  80                 if (is_callable('stream_set_read_buffer')) {
  81                     stream_set_read_buffer($fp, RANDOM_COMPAT_READ_BUFFER);
  82                 }
  83                 if (is_callable('stream_set_chunk_size')) {
  84                     stream_set_chunk_size($fp, RANDOM_COMPAT_READ_BUFFER);
  85                 }
  86             }
  87         }
  88
  89         try {
  90             /** @var int $bytes */
  91             $bytes = RandomCompat_intval($bytes);
  92         } catch (TypeError $ex) {
  93             throw new TypeError(
  94                 'random_bytes(): $bytes must be an integer'
  95             );
  96         }
  97
  98         if ($bytes < 1) {
  99             throw new Error(
 100                 'Length must be greater than 0'
 101             );
 102         }
 103
 104         /**
 105          * This if() block only runs if we managed to open a file handle
 106          *
 107          * It does not belong in an else {} block, because the above
 108          * if (empty($fp)) line is logic that should only be run once per
 109          * page load.
 110          */
 111         if (is_resource($fp)) {
 112             /**
 113              * @var int
 114              */
 115             $remaining = $bytes;
 116
 117             /**
 118              * @var string|bool
 119              */
 120             $buf = '';
 121
 122             /**
 123              * We use fread() in a loop to protect against partial reads
 124              */
 125             do {
 126                 /**
 127                  * @var string|bool
 128                  */
 129                 $read = fread($fp, $remaining);
 130                 if (!is_string($read)) {
 131                     if ($read === false) {
 132                         /**
 133                          * We cannot safely read from the file. Exit the
 134                          * do-while loop and trigger the exception condition
 135                          *
 136                          * @var string|bool
 137                          */
 138                         $buf = false;
 139                         break;
 140                     }
 141                 }
 142                 /**
 143                  * Decrease the number of bytes returned from remaining
 144                  */
 145                 $remaining -= RandomCompat_strlen($read);
 146                 /**
 147                  * @var string|bool
 148                  */
 149                 $buf = $buf . $read;
 150             } while ($remaining > 0);
 151
 152             /**
 153              * Is our result valid?
 154              */
 155             if (is_string($buf)) {
 156                 if (RandomCompat_strlen($buf) === $bytes) {
 157                     /**
 158                      * Return our random entropy buffer here:
 159                      */
 160                     return $buf;
 161                 }
 162             }
 163         }
 164
 165         /**
 166          * If we reach here, PHP has failed us.
 167          */
 168         throw new Exception(
 169             'Error reading from source device'
 170         );
 171     }
 172 }