New file |
0,0 → 1,444 |
<?php |
|
/** |
* BigMath: A math library wrapper that abstracts out the underlying |
* long integer library. |
* |
* PHP versions 4 and 5 |
* |
* LICENSE: See the COPYING file included in this distribution. |
* |
* @access private |
* @package OpenID |
* @author JanRain, Inc. <openid@janrain.com> |
* @copyright 2005 Janrain, Inc. |
* @license http://www.gnu.org/copyleft/lesser.html LGPL |
*/ |
|
/** |
* Needed for random number generation |
*/ |
require_once 'Auth/OpenID/CryptUtil.php'; |
|
/** |
* The superclass of all big-integer math implementations |
* @access private |
* @package OpenID |
*/ |
class Auth_OpenID_MathLibrary { |
/** |
* Given a long integer, returns the number converted to a binary |
* string. This function accepts long integer values of arbitrary |
* magnitude and uses the local large-number math library when |
* available. |
* |
* @param integer $long The long number (can be a normal PHP |
* integer or a number created by one of the available long number |
* libraries) |
* @return string $binary The binary version of $long |
*/ |
function longToBinary($long) |
{ |
$cmp = $this->cmp($long, 0); |
if ($cmp < 0) { |
$msg = __FUNCTION__ . " takes only positive integers."; |
trigger_error($msg, E_USER_ERROR); |
return null; |
} |
|
if ($cmp == 0) { |
return "\x00"; |
} |
|
$bytes = array(); |
|
while ($this->cmp($long, 0) > 0) { |
array_unshift($bytes, $this->mod($long, 256)); |
$long = $this->div($long, pow(2, 8)); |
} |
|
if ($bytes && ($bytes[0] > 127)) { |
array_unshift($bytes, 0); |
} |
|
$string = ''; |
foreach ($bytes as $byte) { |
$string .= pack('C', $byte); |
} |
|
return $string; |
} |
|
/** |
* Given a binary string, returns the binary string converted to a |
* long number. |
* |
* @param string $binary The binary version of a long number, |
* probably as a result of calling longToBinary |
* @return integer $long The long number equivalent of the binary |
* string $str |
*/ |
function binaryToLong($str) |
{ |
if ($str === null) { |
return null; |
} |
|
// Use array_merge to return a zero-indexed array instead of a |
// one-indexed array. |
$bytes = array_merge(unpack('C*', $str)); |
|
$n = $this->init(0); |
|
if ($bytes && ($bytes[0] > 127)) { |
trigger_error("bytesToNum works only for positive integers.", |
E_USER_WARNING); |
return null; |
} |
|
foreach ($bytes as $byte) { |
$n = $this->mul($n, pow(2, 8)); |
$n = $this->add($n, $byte); |
} |
|
return $n; |
} |
|
function base64ToLong($str) |
{ |
$b64 = base64_decode($str); |
|
if ($b64 === false) { |
return false; |
} |
|
return $this->binaryToLong($b64); |
} |
|
function longToBase64($str) |
{ |
return base64_encode($this->longToBinary($str)); |
} |
|
/** |
* Returns a random number in the specified range. This function |
* accepts $start, $stop, and $step values of arbitrary magnitude |
* and will utilize the local large-number math library when |
* available. |
* |
* @param integer $start The start of the range, or the minimum |
* random number to return |
* @param integer $stop The end of the range, or the maximum |
* random number to return |
* @param integer $step The step size, such that $result - ($step |
* * N) = $start for some N |
* @return integer $result The resulting randomly-generated number |
*/ |
function rand($stop) |
{ |
static $duplicate_cache = array(); |
|
// Used as the key for the duplicate cache |
$rbytes = $this->longToBinary($stop); |
|
if (array_key_exists($rbytes, $duplicate_cache)) { |
list($duplicate, $nbytes) = $duplicate_cache[$rbytes]; |
} else { |
if ($rbytes[0] == "\x00") { |
$nbytes = strlen($rbytes) - 1; |
} else { |
$nbytes = strlen($rbytes); |
} |
|
$mxrand = $this->pow(256, $nbytes); |
|
// If we get a number less than this, then it is in the |
// duplicated range. |
$duplicate = $this->mod($mxrand, $stop); |
|
if (count($duplicate_cache) > 10) { |
$duplicate_cache = array(); |
} |
|
$duplicate_cache[$rbytes] = array($duplicate, $nbytes); |
} |
|
do { |
$bytes = "\x00" . Auth_OpenID_CryptUtil::getBytes($nbytes); |
$n = $this->binaryToLong($bytes); |
// Keep looping if this value is in the low duplicated range |
} while ($this->cmp($n, $duplicate) < 0); |
|
return $this->mod($n, $stop); |
} |
} |
|
/** |
* Exposes BCmath math library functionality. |
* |
* {@link Auth_OpenID_BcMathWrapper} wraps the functionality provided |
* by the BCMath extension. |
* |
* @access private |
* @package OpenID |
*/ |
class Auth_OpenID_BcMathWrapper extends Auth_OpenID_MathLibrary{ |
var $type = 'bcmath'; |
|
function add($x, $y) |
{ |
return bcadd($x, $y); |
} |
|
function sub($x, $y) |
{ |
return bcsub($x, $y); |
} |
|
function pow($base, $exponent) |
{ |
return bcpow($base, $exponent); |
} |
|
function cmp($x, $y) |
{ |
return bccomp($x, $y); |
} |
|
function init($number, $base = 10) |
{ |
return $number; |
} |
|
function mod($base, $modulus) |
{ |
return bcmod($base, $modulus); |
} |
|
function mul($x, $y) |
{ |
return bcmul($x, $y); |
} |
|
function div($x, $y) |
{ |
return bcdiv($x, $y); |
} |
|
/** |
* Same as bcpowmod when bcpowmod is missing |
* |
* @access private |
*/ |
function _powmod($base, $exponent, $modulus) |
{ |
$square = $this->mod($base, $modulus); |
$result = 1; |
while($this->cmp($exponent, 0) > 0) { |
if ($this->mod($exponent, 2)) { |
$result = $this->mod($this->mul($result, $square), $modulus); |
} |
$square = $this->mod($this->mul($square, $square), $modulus); |
$exponent = $this->div($exponent, 2); |
} |
return $result; |
} |
|
function powmod($base, $exponent, $modulus) |
{ |
if (function_exists('bcpowmod')) { |
return bcpowmod($base, $exponent, $modulus); |
} else { |
return $this->_powmod($base, $exponent, $modulus); |
} |
} |
|
function toString($num) |
{ |
return $num; |
} |
} |
|
/** |
* Exposes GMP math library functionality. |
* |
* {@link Auth_OpenID_GmpMathWrapper} wraps the functionality provided |
* by the GMP extension. |
* |
* @access private |
* @package OpenID |
*/ |
class Auth_OpenID_GmpMathWrapper extends Auth_OpenID_MathLibrary{ |
var $type = 'gmp'; |
|
function add($x, $y) |
{ |
return gmp_add($x, $y); |
} |
|
function sub($x, $y) |
{ |
return gmp_sub($x, $y); |
} |
|
function pow($base, $exponent) |
{ |
return gmp_pow($base, $exponent); |
} |
|
function cmp($x, $y) |
{ |
return gmp_cmp($x, $y); |
} |
|
function init($number, $base = 10) |
{ |
return gmp_init($number, $base); |
} |
|
function mod($base, $modulus) |
{ |
return gmp_mod($base, $modulus); |
} |
|
function mul($x, $y) |
{ |
return gmp_mul($x, $y); |
} |
|
function div($x, $y) |
{ |
return gmp_div_q($x, $y); |
} |
|
function powmod($base, $exponent, $modulus) |
{ |
return gmp_powm($base, $exponent, $modulus); |
} |
|
function toString($num) |
{ |
return gmp_strval($num); |
} |
} |
|
/** |
* Define the supported extensions. An extension array has keys |
* 'modules', 'extension', and 'class'. 'modules' is an array of PHP |
* module names which the loading code will attempt to load. These |
* values will be suffixed with a library file extension (e.g. ".so"). |
* 'extension' is the name of a PHP extension which will be tested |
* before 'modules' are loaded. 'class' is the string name of a |
* {@link Auth_OpenID_MathWrapper} subclass which should be |
* instantiated if a given extension is present. |
* |
* You can define new math library implementations and add them to |
* this array. |
*/ |
global $_Auth_OpenID_math_extensions; |
$_Auth_OpenID_math_extensions = array( |
array('modules' => array('gmp', 'php_gmp'), |
'extension' => 'gmp', |
'class' => 'Auth_OpenID_GmpMathWrapper'), |
array('modules' => array('bcmath', 'php_bcmath'), |
'extension' => 'bcmath', |
'class' => 'Auth_OpenID_BcMathWrapper') |
); |
|
/** |
* Detect which (if any) math library is available |
*/ |
function Auth_OpenID_detectMathLibrary($exts) |
{ |
$loaded = false; |
|
foreach ($exts as $extension) { |
// See if the extension specified is already loaded. |
if ($extension['extension'] && |
extension_loaded($extension['extension'])) { |
$loaded = true; |
} |
|
// Try to load dynamic modules. |
if (!$loaded) { |
foreach ($extension['modules'] as $module) { |
if (@dl($module . "." . PHP_SHLIB_SUFFIX)) { |
$loaded = true; |
break; |
} |
} |
} |
|
// If the load succeeded, supply an instance of |
// Auth_OpenID_MathWrapper which wraps the specified |
// module's functionality. |
if ($loaded) { |
return $extension; |
} |
} |
|
return false; |
} |
|
/** |
* {@link Auth_OpenID_getMathLib} checks for the presence of long |
* number extension modules and returns an instance of |
* {@link Auth_OpenID_MathWrapper} which exposes the module's |
* functionality. |
* |
* Checks for the existence of an extension module described by the |
* local {@link Auth_OpenID_math_extensions} array and returns an |
* instance of a wrapper for that extension module. If no extension |
* module is found, an instance of {@link Auth_OpenID_MathWrapper} is |
* returned, which wraps the native PHP integer implementation. The |
* proper calling convention for this method is $lib =& |
* Auth_OpenID_getMathLib(). |
* |
* This function checks for the existence of specific long number |
* implementations in the following order: GMP followed by BCmath. |
* |
* @return Auth_OpenID_MathWrapper $instance An instance of |
* {@link Auth_OpenID_MathWrapper} or one of its subclasses |
* |
* @package OpenID |
*/ |
function &Auth_OpenID_getMathLib() |
{ |
// The instance of Auth_OpenID_MathWrapper that we choose to |
// supply will be stored here, so that subseqent calls to this |
// method will return a reference to the same object. |
static $lib = null; |
|
if (isset($lib)) { |
return $lib; |
} |
|
if (defined('Auth_OpenID_NO_MATH_SUPPORT')) { |
$null = null; |
return $null; |
} |
|
// If this method has not been called before, look at |
// $Auth_OpenID_math_extensions and try to find an extension that |
// works. |
global $_Auth_OpenID_math_extensions; |
$ext = Auth_OpenID_detectMathLibrary($_Auth_OpenID_math_extensions); |
if ($ext === false) { |
$tried = array(); |
foreach ($_Auth_OpenID_math_extensions as $extinfo) { |
$tried[] = $extinfo['extension']; |
} |
$triedstr = implode(", ", $tried); |
|
define('Auth_OpenID_NO_MATH_SUPPORT', true); |
return null; |
} |
|
// Instantiate a new wrapper |
$class = $ext['class']; |
$lib = new $class(); |
|
return $lib; |
} |
|
?> |