]> git.mxchange.org Git - core.git/blob - framework/main/classes/rng/class_RandomNumberGenerator.php
Continued:
[core.git] / framework / main / classes / rng / class_RandomNumberGenerator.php
1 <?php
2 // Own namespace
3 namespace Org\Mxchange\CoreFramework\Crypto\RandomNumber;
4
5 // Import framework stuff
6 use Org\Mxchange\CoreFramework\Bootstrap\FrameworkBootstrap;
7 use Org\Mxchange\CoreFramework\Object\BaseFrameworkSystem;
8 use Org\Mxchange\CoreFramework\Generic\FrameworkInterface;
9
10 /**
11  * A standard random number generator
12  *
13  * @author              Roland Haeder <webmaster@shipsimu.org>
14  * @version             0.0.0
15  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2020 Core Developer Team
16  * @license             GNU GPL 3.0 or any newer version
17  * @link                http://www.shipsimu.org
18  *
19  * This program is free software: you can redistribute it and/or modify
20  * it under the terms of the GNU General Public License as published by
21  * the Free Software Foundation, either version 3 of the License, or
22  * (at your option) any later version.
23  *
24  * This program is distributed in the hope that it will be useful,
25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27  * GNU General Public License for more details.
28  *
29  * You should have received a copy of the GNU General Public License
30  * along with this program. If not, see <http://www.gnu.org/licenses/>.
31  */
32 class RandomNumberGenerator extends BaseFrameworkSystem {
33         /**
34          * Prime number for better pseudo random numbers
35          */
36         private $prime = 0;
37
38         /**
39          * Add this calculated number to the rng
40          */
41         private $extraNumber = 0;
42
43         /**
44          * Extra salt for secured hashing
45          */
46         private $extraSalt = '';
47
48         /**
49          * Fixed salt for secured hashing
50          */
51         private $fixedSalt = '';
52
53         /**
54          * Maximum length for random string
55          */
56         private $rndStrLen = 0;
57
58         /**
59          * Self instance
60          */
61         private static $selfInstance = NULL;
62
63         /**
64          * Protected constructor
65          *
66          * @param       $className      Name of this class
67          * @return      void
68          */
69         protected function __construct ($className = __CLASS__) {
70                 // Call parent constructor
71                 parent::__construct($className);
72         }
73
74         /**
75          * Creates an instance of this class
76          *
77          * @param       $extraInstance  An extra instance for more salt (default: null)
78          * @return      $rngInstance    An instance of this random number generator
79          */
80         public static final function createRandomNumberGenerator (FrameworkInterface $extraInstance = NULL) {
81                 // Is self instance set?
82                 if (is_null(self::$selfInstance)) {
83                         // Get a new instance
84                         $rngInstance = new RandomNumberGenerator();
85
86                         // Initialize the RNG now
87                         $rngInstance->initRng($extraInstance);
88
89                         // Set it "self"
90                         self::$selfInstance = $rngInstance;
91                 } else {
92                         // Use from self instance
93                         $rngInstance = self::$selfInstance;
94                 }
95
96                 // Return the instance
97                 return $rngInstance;
98         }
99
100         /**
101          * Initializes the random number generator
102          *
103          * @param       $extraInstance  An extra instance for more salt (default: null)
104          * @return      void
105          * @todo        Add site key for stronger salt!
106          */
107         protected function initRng ($extraInstance) {
108                 // Get the prime number from config
109                 $this->prime = $this->getConfigInstance()->getConfigEntry('math_prime');
110
111                 // Calculate the extra number which is always the same unless you give
112                 // a better prime number
113                 $this->extraNumber = ($this->prime * $this->prime / pow(pi(), 2));
114
115                 // Seed mt_rand()
116                 mt_srand((double) sqrt(microtime(true) * 100000000 * $this->extraNumber));
117
118                 // Set the server IP to cluster
119                 $serverIp = 'cluster';
120
121                 // Do we have a single server?
122                 if ($this->getConfigInstance()->getConfigEntry('is_single_server') == 'Y') {
123                         // Then use that IP for extra security
124                         $serverIp = FrameworkBootstrap::detectServerAddress();
125                 } // END - if
126
127                 // Yet-another fixed salt. This is not dependend on server software or date
128                 if ($extraInstance instanceof FrameworkInterface) {
129                         // With extra instance information
130                         $this->fixedSalt = sha1(
131                                 $serverIp . ':' .
132                                 $extraInstance->__toString() . ':' .
133                                 json_encode(FrameworkBootstrap::getDatabaseInstance()->getConnectionData())
134                         );
135                 } else {
136                         // Without extra information
137                         $this->fixedSalt = sha1($serverIp . ':' . json_encode(FrameworkBootstrap::getDatabaseInstance()->getConnectionData()));
138                 }
139
140                 // One-way data we need for "extra-salting" the random number
141                 $this->extraSalt = sha1(
142                         $this->fixedSalt . ':' .
143                         getenv('SERVER_SOFTWARE') . ':' .
144                         $this->getConfigInstance()->getConfigEntry('date_key') . ':' .
145                         $this->getConfigInstance()->getConfigEntry('base_url')
146                 );
147
148                 // Get config entry for max salt length
149                 $this->rndStrLen = $this->getConfigInstance()->getConfigEntry('rnd_str_length');
150         }
151
152         /**
153          * Makes a pseudo-random string useable for salts
154          *
155          * @param       $length                 Length of the string, default: 128
156          * @return      $randomString   The pseudo-random string
157          */
158         public function randomString ($length = -1) {
159                 // Is the number <1, then fix it to default length
160                 if ($length < 1) {
161                         $length = $this->rndStrLen;
162                 } // END - if
163
164                 // Initialize the string
165                 $randomString = '';
166
167                 // And generate it
168                 for ($idx = 0; $idx < $length; $idx++) {
169                         // Add a random character and add it to our string
170                         $randomString .= chr($this->randomNumber(0, 255));
171                 } // END - for
172
173                 // Return the random string a little mixed up
174                 return str_shuffle($randomString);
175         }
176
177         /**
178          * Generate a pseudo-random integer number in a given range
179          *
180          * @param       $min    Min value to generate
181          * @param       $max    Max value to generate
182          * @return      $num    Pseudo-random number
183          * @todo        I had a better random number generator here but now it is somewhere lost :(
184          */
185         public function randomNumber ($min, $max) {
186                 return mt_rand($min, $max);
187         }
188
189         /**
190          * Getter for extra salt
191          *
192          * @return      $extraSalt
193          */
194         public final function getExtraSalt () {
195                 return $this->extraSalt;
196         }
197
198         /**
199          * Getter for fixed salt
200          *
201          * @return      $fixedSalt
202          */
203         public final function getFixedSalt () {
204                 return $this->fixedSalt;
205         }
206
207         /**
208          * Generates a key based on if we have extra (default) or fixed salt enabled
209          *
210          * @return      $key    The generated key for encryption
211          */
212         public function generateKey () {
213                 // Default is extra salt
214                 $key = md5($this->getExtraSalt());
215
216                 // Get key
217                 if ($this->getConfigInstance()->getConfigEntry('crypt_fixed_salt') == 'Y') {
218                         $key = md5($this->getFixedSalt());
219                 } // END - if
220
221                 // Return it
222                 return $key;
223         }
224
225 }