From cd40f978f769c6029fdb5839ca0e2f71485e5eae Mon Sep 17 00:00:00 2001 From: Jim Wigginton Date: Sun, 7 Jun 2009 00:51:45 +0000 Subject: - added sftp support git-svn-id: file:///svn/phpbb/trunk@9553 89ea8834-ac86-4346-8a33-228a782c2dd0 --- phpBB/includes/sftp/biginteger.php | 2162 ++++++++++++++++++++++++++++++++++++ 1 file changed, 2162 insertions(+) create mode 100644 phpBB/includes/sftp/biginteger.php (limited to 'phpBB/includes/sftp/biginteger.php') diff --git a/phpBB/includes/sftp/biginteger.php b/phpBB/includes/sftp/biginteger.php new file mode 100644 index 0000000000..d9b90dacb8 --- /dev/null +++ b/phpBB/includes/sftp/biginteger.php @@ -0,0 +1,2162 @@ + +* Copyright 2009+ phpBB +* +* @package sftp +* @author TerraFrost +*/ + +/**#@+ + * @access private + * @see biginteger::_sliding_window() + */ +/** + * @see biginteger::_montgomery() + * @see biginteger::_undo_montgomery() + */ +define('MATH_BIGINTEGER_MONTGOMERY', 0); +/** + * @see biginteger::_barrett() + */ +define('MATH_BIGINTEGER_BARRETT', 1); +/** + * @see biginteger::_mod2() + */ +define('MATH_BIGINTEGER_POWEROF2', 2); +/** + * @see biginteger::_remainder() + */ +define('MATH_BIGINTEGER_CLASSIC', 3); +/** + * @see biginteger::_copy() + */ +define('MATH_BIGINTEGER_NONE', 4); +/**#@-*/ + +/**#@+ + * @access private + * @see biginteger::_montgomery() + * @see biginteger::_barrett() + */ +/** + * $cache[MATH_BIGINTEGER_VARIABLE] tells us whether or not the cached data is still valid. + */ +define('MATH_BIGINTEGER_VARIABLE', 0); +/** + * $cache[MATH_BIGINTEGER_DATA] contains the cached data. + */ +define('MATH_BIGINTEGER_DATA', 1); +/**#@-*/ + +/**#@+ + * @access private + * @see biginteger::biginteger() + */ +/** + * To use the pure-PHP implementation + */ +define('MATH_BIGINTEGER_MODE_INTERNAL', 1); +/** + * To use the BCMath library + * + * (if enabled; otherwise, the internal implementation will be used) + */ +define('MATH_BIGINTEGER_MODE_BCMATH', 2); +/** + * To use the GMP library + * + * (if present; otherwise, either the BCMath or the internal implementation will be used) + */ +define('MATH_BIGINTEGER_MODE_GMP', 3); +/**#@-*/ + +/** + * Pure-PHP arbitrary precision integer arithmetic library. Supports base-2, base-10, base-16, and base-256 + * numbers. + * + * @author Jim Wigginton + * @version 1.0.0RC3 + * @access public + * @package biginteger + */ +class biginteger +{ + /** + * Holds the BigInteger's value. + * + * @var Array + * @access private + */ + var $value; + + /** + * Holds the BigInteger's magnitude. + * + * @var Boolean + * @access private + */ + var $is_negative = false; + + /** + * Converts base-2, base-10, base-16, and binary strings (eg. base-256) to BigIntegers. + * + * If the second parameter - $base - is negative, then it will be assumed that the number's are encoded using + * two's compliment. The sole exception to this is -10, which is treated the same as 10 is. + * + * @param optional $x base-10 number or base-$base number if $base set. + * @param optional integer $base + * @return biginteger + * @access public + */ + function __construct($x = 0, $base = 10) + { + if ( !defined('MATH_BIGINTEGER_MODE') ) + { + switch (true) + { + case extension_loaded('gmp'): + define('MATH_BIGINTEGER_MODE', MATH_BIGINTEGER_MODE_GMP); + break; + case extension_loaded('bcmath'): + define('MATH_BIGINTEGER_MODE', MATH_BIGINTEGER_MODE_BCMATH); + break; + default: + define('MATH_BIGINTEGER_MODE', MATH_BIGINTEGER_MODE_INTERNAL); + } + } + + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $this->value = gmp_init(0); + break; + case MATH_BIGINTEGER_MODE_BCMATH: + $this->value = '0'; + break; + default: + $this->value = array(); + } + + if ($x === 0) + { + return; + } + + switch ($base) + { + case -256: + if (ord($x[0]) & 0x80) + { + $x = ~$x; + $this->is_negative = true; + } + case 256: + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = unpack('H*hex', $x); + $sign = $this->is_negative ? '-' : ''; + $this->value = gmp_init($sign . '0x' . $temp['hex']); + break; + case MATH_BIGINTEGER_MODE_BCMATH: + // round $len to the nearest 4 (thanks, DavidMJ!) + $len = (strlen($x) + 3) & 0xFFFFFFFC; + + $x = str_pad($x, $len, chr(0), STR_PAD_LEFT); + + for ($i = 0; $i < $len; $i+= 4) { + $this->value = bcmul($this->value, '4294967296'); // 4294967296 == 2**32 + $this->value = bcadd($this->value, 0x1000000 * ord($x[$i]) + ((ord($x[$i + 1]) << 16) | (ord($x[$i + 2]) << 8) | ord($x[$i + 3]))); + } + + if ($this->is_negative) { + $this->value = '-' . $this->value; + } + + break; + // converts a base-2**8 (big endian / msb) number to base-2**26 (little endian / lsb) + case MATH_BIGINTEGER_MODE_INTERNAL: + while (strlen($x)) + { + $this->value[] = $this->_bytes2int($this->_base256_rshift($x, 26)); + } + } + + if ($this->is_negative) + { + if (MATH_BIGINTEGER_MODE != MATH_BIGINTEGER_MODE_INTERNAL) + { + $this->is_negative = false; + } + $temp = $this->add(new biginteger('-1')); + $this->value = $temp->value; + } + break; + case 16: + case -16: + if ($base > 0 && $x[0] == '-') + { + $this->is_negative = true; + $x = substr($x, 1); + } + + $x = preg_replace('#^(?:0x)?([A-Fa-f0-9]*).*#', '$1', $x); + + $is_negative = false; + if ($base < 0 && hexdec($x[0]) >= 8) + { + $this->is_negative = $is_negative = true; + $x = bin2hex(~pack('H*', $x)); + } + + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = $this->is_negative ? '-0x' . $x : '0x' . $x; + $this->value = gmp_init($temp); + $this->is_negative = false; + break; + case MATH_BIGINTEGER_MODE_BCMATH: + $x = ( strlen($x) & 1 ) ? '0' . $x : $x; + $temp = new biginteger(pack('H*', $x), 256); + $this->value = $this->is_negative ? '-' . $temp->value : $temp->value; + $this->is_negative = false; + break; + case MATH_BIGINTEGER_MODE_INTERNAL: + $x = ( strlen($x) & 1 ) ? '0' . $x : $x; + $temp = new biginteger(pack('H*', $x), 256); + $this->value = $temp->value; + } + + if ($is_negative) + { + $temp = $this->add(new biginteger('-1')); + $this->value = $temp->value; + } + break; + case 10: + case -10: + $x = preg_replace('#^(-?[0-9]*).*#', '$1', $x); + + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $this->value = gmp_init($x); + break; + case MATH_BIGINTEGER_MODE_BCMATH: + // explicitly casting $x to a string is necessary, here, since doing $x[0] on -1 yields different + // results then doing it on '-1' does (modInverse does $x[0]) + $this->value = (string) $x; + break; + case MATH_BIGINTEGER_MODE_INTERNAL: + $temp = new biginteger(); + + // array(10000000) is 10**7 in base-2**26. 10**7 is the closest to 2**26 we can get without passing it. + $multiplier = new biginteger(); + $multiplier->value = array(10000000); + + if ($x[0] == '-') + { + $this->is_negative = true; + $x = substr($x, 1); + } + + $x = str_pad($x, strlen($x) + (6 * strlen($x)) % 7, 0, STR_PAD_LEFT); + + while (strlen($x)) + { + $temp = $temp->multiply($multiplier); + $temp = $temp->add(new biginteger($this->_int2bytes(substr($x, 0, 7)), 256)); + $x = substr($x, 7); + } + + $this->value = $temp->value; + } + break; + case 2: // base-2 support originally implemented by Lluis Pamies - thanks! + case -2: + if ($base > 0 && $x[0] == '-') + { + $this->is_negative = true; + $x = substr($x, 1); + } + + $x = preg_replace('#^([01]*).*#', '$1', $x); + $x = str_pad($x, strlen($x) + (3 * strlen($x)) % 4, 0, STR_PAD_LEFT); + + $str = '0x'; + while (strlen($x)) + { + $part = substr($x, 0, 4); + $str.= dechex(bindec($part)); + $x = substr($x, 4); + } + + if ($this->is_negative) + { + $str = '-' . $str; + } + + $temp = new biginteger($str, 8 * $base); // ie. either -16 or +16 + $this->value = $temp->value; + $this->is_negative = $temp->is_negative; + + break; + default: + // base not supported, so we'll let $this == 0 + } + } + + /** + * Converts a BigInteger to a byte string (eg. base-256). + * + * Negative numbers are saved as positive numbers, unless $twos_compliment is set to true, at which point, they're + * saved as two's compliment. + * + * @param Boolean $twos_compliment + * @return String + * @access public + * @internal Converts a base-2**26 number to base-2**8 + */ + function to_bytes($twos_compliment = false) + { + if ($twos_compliment) + { + $comparison = $this->compare(new biginteger()); + if ($comparison == 0) + { + return ''; + } + + $temp = $comparison < 0 ? $this->add(new biginteger(1)) : $this->_copy(); + $bytes = $temp->to_bytes(); + + if (empty($bytes)) // eg. if the number we're trying to convert is -1 + { + $bytes = chr(0); + } + + if (ord($bytes[0]) & 0x80) + { + $bytes = chr(0) . $bytes; + } + + return $comparison < 0 ? ~$bytes : $bytes; + } + + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + if (gmp_cmp($this->value, gmp_init(0)) == 0) + { + return ''; + } + + $temp = gmp_strval(gmp_abs($this->value), 16); + $temp = ( strlen($temp) & 1 ) ? '0' . $temp : $temp; + + return ltrim(pack('H*', $temp), chr(0)); + case MATH_BIGINTEGER_MODE_BCMATH: + if ($this->value === '0') + { + return ''; + } + + $value = ''; + $current = $this->value; + + if ($current[0] == '-') + { + $current = substr($current, 1); + } + + // we don't do four bytes at a time because then numbers larger than 1<<31 would be negative + // two's complimented numbers, which would break chr. + while (bccomp($current, '0') > 0) + { + $temp = bcmod($current, 0x1000000); + $value = chr($temp >> 16) . chr($temp >> 8) . chr($temp) . $value; + $current = bcdiv($current, 0x1000000); + } + + return ltrim($value, chr(0)); + } + + if (!count($this->value)) + { + return ''; + } + + $result = $this->_int2bytes($this->value[count($this->value) - 1]); + + $temp = $this->_copy(); + + for ($i = count($temp->value) - 2; $i >= 0; $i--) + { + $temp->_base256_lshift($result, 26); + $result = $result | str_pad($temp->_int2bytes($temp->value[$i]), strlen($result), chr(0), STR_PAD_LEFT); + } + + return $result; + } + + /** + * Converts a BigInteger to a base-10 number. + * + * @return String + * @access public + * @internal Converts a base-2**26 number to base-10**7 (which is pretty much base-10) + */ + function to_string() + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + return gmp_strval($this->value); + case MATH_BIGINTEGER_MODE_BCMATH: + if ($this->value === '0') + { + return '0'; + } + + return ltrim($this->value, '0'); + } + + if (!count($this->value)) + { + return '0'; + } + + $temp = $this->_copy(); + $temp->is_negative = false; + + $divisor = new biginteger(); + $divisor->value = array(10000000); // eg. 10**7 + while (count($temp->value)) + { + list($temp, $mod) = $temp->divide($divisor); + $result = str_pad($this->_bytes2int($mod->to_bytes()), 7, '0', STR_PAD_LEFT) . $result; + } + $result = ltrim($result, '0'); + + if ($this->is_negative) + { + $result = '-' . $result; + } + + return $result; + } + + /** + * __toString() magic method + * + * Will be called, automatically, if you're supporting just PHP5. If you're supporting PHP4, you'll need to call + * toString(). + * + * @access public + * @internal Implemented per a suggestion by Techie-Michael - thanks! + */ + function __toString() + { + return $this->to_string(); + } + + /** + * Adds two BigIntegers. + * + * @param biginteger $y + * @return biginteger + * @access public + * @internal Performs base-2**52 addition + */ + function add($y) + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = new biginteger(); + $temp->value = gmp_add($this->value, $y->value); + + return $temp; + case MATH_BIGINTEGER_MODE_BCMATH: + $temp = new biginteger(); + $temp->value = bcadd($this->value, $y->value); + + return $temp; + } + + // subtract, if appropriate + if ( $this->is_negative != $y->is_negative ) + { + // is $y the negative number? + $y_negative = $this->compare($y) > 0; + + $temp = $this->_copy(); + $y = $y->_copy(); + $temp->is_negative = $y->is_negative = false; + + $diff = $temp->compare($y); + if ( !$diff ) + { + return new biginteger(); + } + + $temp = $temp->subtract($y); + + $temp->is_negative = ($diff > 0) ? !$y_negative : $y_negative; + + return $temp; + } + + $result = new biginteger(); + $carry = 0; + + $size = max(count($this->value), count($y->value)); + $size+= $size & 1; // rounds $size to the nearest 2. + + $x = array_pad($this->value, $size,0); + $y = array_pad($y->value, $size, 0); + + for ($i = 0; $i < $size - 1; $i+=2) + { + $sum = $x[$i + 1] * 0x4000000 + $x[$i] + $y[$i + 1] * 0x4000000 + $y[$i] + $carry; + $carry = $sum >= 4503599627370496; // eg. floor($sum / 2**52); only possible values (in any base) are 0 and 1 + $sum = $carry ? $sum - 4503599627370496 : $sum; + + $temp = floor($sum / 0x4000000); + + $result->value[] = $sum - 0x4000000 * $temp; // eg. a faster alternative to fmod($sum, 0x4000000) + $result->value[] = $temp; + } + + if ($carry) + { + $result->value[] = $carry; + } + + $result->is_negative = $this->is_negative; + + return $result->_normalize(); + } + + /** + * Subtracts two BigIntegers. + * + * @param biginteger $y + * @return biginteger + * @access public + * @internal Performs base-2**52 subtraction + */ + function subtract($y) + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = new biginteger(); + $temp->value = gmp_sub($this->value, $y->value); + + return $temp; + case MATH_BIGINTEGER_MODE_BCMATH: + $temp = new biginteger(); + $temp->value = bcsub($this->value, $y->value); + + return $temp; + } + + // add, if appropriate + if ( $this->is_negative != $y->is_negative ) + { + $is_negative = $y->compare($this) > 0; + + $temp = $this->_copy(); + $y = $y->_copy(); + $temp->is_negative = $y->is_negative = false; + + $temp = $temp->add($y); + + $temp->is_negative = $is_negative; + + return $temp; + } + + $diff = $this->compare($y); + + if ( !$diff ) + { + return new biginteger(); + } + + // switch $this and $y around, if appropriate. + if ( (!$this->is_negative && $diff < 0) || ($this->is_negative && $diff > 0) ) + { + $is_negative = $y->is_negative; + + $temp = $this->_copy(); + $y = $y->_copy(); + $temp->is_negative = $y->is_negative = false; + + $temp = $y->subtract($temp); + $temp->is_negative = !$is_negative; + + return $temp; + } + + $result = new biginteger(); + $carry = 0; + + $size = max(count($this->value), count($y->value)); + $size+= $size % 2; + + $x = array_pad($this->value, $size, 0); + $y = array_pad($y->value, $size, 0); + + for ($i = 0; $i < $size - 1; $i+=2) + { + $sum = $x[$i + 1] * 0x4000000 + $x[$i] - $y[$i + 1] * 0x4000000 - $y[$i] + $carry; + $carry = $sum < 0 ? -1 : 0; // eg. floor($sum / 2**52); only possible values (in any base) are 0 and 1 + $sum = $carry ? $sum + 4503599627370496 : $sum; + + $temp = floor($sum / 0x4000000); + + $result->value[] = $sum - 0x4000000 * $temp; + $result->value[] = $temp; + } + + // $carry shouldn't be anything other than zero, at this point, since we already made sure that $this + // was bigger than $y. + + $result->is_negative = $this->is_negative; + + return $result->_normalize(); + } + + /** + * Multiplies two BigIntegers + * + * @param biginteger $x + * @return biginteger + * @access public + * @internal Modeled after 'multiply' in MutableBigInteger.java. + */ + function multiply($x) + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = new biginteger(); + $temp->value = gmp_mul($this->value, $x->value); + + return $temp; + case MATH_BIGINTEGER_MODE_BCMATH: + $temp = new biginteger(); + $temp->value = bcmul($this->value, $x->value); + + return $temp; + } + + if ( !$this->compare($x) ) + { + return $this->_square(); + } + + $this_length = count($this->value); + $x_length = count($x->value); + + if ( !$this_length || !$x_length ) // a 0 is being multiplied + { + return new biginteger(); + } + + $product = new biginteger(); + $product->value = $this->_array_repeat(0, $this_length + $x_length); + + // the following for loop could be removed if the for loop following it + // (the one with nested for loops) initially set $i to 0, but + // doing so would also make the result in one set of unnecessary adds, + // since on the outermost loops first pass, $product->value[$k] is going + // to always be 0 + + $carry = 0; + $i = 0; + + for ($j = 0, $k = $i; $j < $this_length; $j++, $k++) + { + $temp = $product->value[$k] + $this->value[$j] * $x->value[$i] + $carry; + $carry = floor($temp / 0x4000000); + $product->value[$k] = $temp - 0x4000000 * $carry; + } + + $product->value[$k] = $carry; + + // the above for loop is what the previous comment was talking about. the + // following for loop is the "one with nested for loops" + + for ($i = 1; $i < $x_length; $i++) + { + $carry = 0; + + for ($j = 0, $k = $i; $j < $this_length; $j++, $k++) + { + $temp = $product->value[$k] + $this->value[$j] * $x->value[$i] + $carry; + $carry = floor($temp / 0x4000000); + $product->value[$k] = $temp - 0x4000000 * $carry; + } + + $product->value[$k] = $carry; + } + + $product->is_negative = $this->is_negative != $x->is_negative; + + return $product->_normalize(); + } + + /** + * Squares a BigInteger + * + * Squaring can be done faster than multiplying a number by itself can be. See + * {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=7 HAC 14.2.4} / + * {@link http://math.libtomcrypt.com/files/tommath.pdf#page=141 MPM 5.3} for more information. + * + * @return biginteger + * @access private + */ + function _square() + { + if ( empty($this->value) ) + { + return new biginteger(); + } + + $max_index = count($this->value) - 1; + + $square = new biginteger(); + $square->value = $this->_array_repeat(0, 2 * $max_index); + + for ($i = 0; $i <= $max_index; $i++) + { + $temp = $square->value[2 * $i] + $this->value[$i] * $this->value[$i]; + $carry = floor($temp / 0x4000000); + $square->value[2 * $i] = $temp - 0x4000000 * $carry; + + // note how we start from $i+1 instead of 0 as we do in multiplication. + for ($j = $i + 1; $j <= $max_index; $j++) + { + $temp = $square->value[$i + $j] + 2 * $this->value[$j] * $this->value[$i] + $carry; + $carry = floor($temp / 0x4000000); + $square->value[$i + $j] = $temp - 0x4000000 * $carry; + } + + // the following line can yield values larger 2**15. at this point, PHP should switch + // over to floats. + $square->value[$i + $max_index + 1] = $carry; + } + + return $square->_normalize(); + } + + /** + * Divides two BigIntegers. + * + * Returns an array whose first element contains the quotient and whose second element contains the + * "common residue". If the remainder would be positive, the "common residue" and the remainder are the + * same. If the remainder would be negative, the "common residue" is equal to the sum of the remainder + * and the divisor (basically, the "common residue" is the first positive modulo). + * + * @param biginteger $y + * @return Array + * @access public + * @internal This function is based off of {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=9 HAC 14.20} + * with a slight variation due to the fact that this script, initially, did not support negative numbers. Now, + * it does, but I don't want to change that which already works. + */ + function divide($y) + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $quotient = new biginteger(); + $remainder = new biginteger(); + + list($quotient->value, $remainder->value) = gmp_div_qr($this->value, $y->value); + + if (gmp_sign($remainder->value) < 0) + { + $remainder->value = gmp_add($remainder->value, gmp_abs($y->value)); + } + + return array($quotient, $remainder); + case MATH_BIGINTEGER_MODE_BCMATH: + $quotient = new biginteger(); + $remainder = new biginteger(); + + $quotient->value = bcdiv($this->value, $y->value); + $remainder->value = bcmod($this->value, $y->value); + + if ($remainder->value[0] == '-') + { + $remainder->value = bcadd($remainder->value, $y->value[0] == '-' ? substr($y->value, 1) : $y->value); + } + + return array($quotient, $remainder); + } + + $x = $this->_copy(); + $y = $y->_copy(); + + $x_sign = $x->is_negative; + $y_sign = $y->is_negative; + + $x->is_negative = $y->is_negative = false; + + $diff = $x->compare($y); + + if ( !$diff ) + { + $temp = new biginteger(); + $temp->value = array(1); + $temp->is_negative = $x_sign != $y_sign; + return array($temp, new biginteger()); + } + + if ( $diff < 0 ) + { + // if $x is negative, "add" $y. + if ( $x_sign ) + { + $x = $y->subtract($x); + } + return array(new biginteger(), $x); + } + + // normalize $x and $y as described in HAC 14.23 / 14.24 + // (incidently, i haven't been able to find a definitive example showing that this + // results in worth-while speedup, but whatever) + $msb = $y->value[count($y->value) - 1]; + for ($shift = 0; !($msb & 0x2000000); $shift++) + { + $msb <<= 1; + } + $x->_lshift($shift); + $y->_lshift($shift); + + $x_max = count($x->value) - 1; + $y_max = count($y->value) - 1; + + $quotient = new biginteger(); + $quotient->value = $this->_array_repeat(0, $x_max - $y_max + 1); + + // $temp = $y << ($x_max - $y_max-1) in base 2**26 + $temp = new biginteger(); + $temp->value = array_merge($this->_array_repeat(0, $x_max - $y_max), $y->value); + + while ( $x->compare($temp) >= 0 ) + { + // calculate the "common residue" + $quotient->value[$x_max - $y_max]++; + $x = $x->subtract($temp); + $x_max = count($x->value) - 1; + } + + for ($i = $x_max; $i >= $y_max + 1; $i--) + { + $x_value = array( + $x->value[$i], + ( $i > 0 ) ? $x->value[$i - 1] : 0, + ( $i - 1 > 0 ) ? $x->value[$i - 2] : 0 + ); + $y_value = array( + $y->value[$y_max], + ( $y_max > 0 ) ? $y_max - 1 : 0 + ); + + + $q_index = $i - $y_max - 1; + if ($x_value[0] == $y_value[0]) + { + $quotient->value[$q_index] = 0x3FFFFFF; + } + else + { + $quotient->value[$q_index] = floor( + ($x_value[0] * 0x4000000 + $x_value[1]) + / + $y_value[0] + ); + } + + $temp = new biginteger(); + $temp->value = array($y_value[1], $y_value[0]); + + $lhs = new biginteger(); + $lhs->value = array($quotient->value[$q_index]); + $lhs = $lhs->multiply($temp); + + $rhs = new biginteger(); + $rhs->value = array($x_value[2], $x_value[1], $x_value[0]); + + while ( $lhs->compare($rhs) > 0 ) + { + $quotient->value[$q_index]--; + + $lhs = new biginteger(); + $lhs->value = array($quotient->value[$q_index]); + $lhs = $lhs->multiply($temp); + } + + $corrector = new biginteger(); + $temp = new biginteger(); + $corrector->value = $temp->value = $this->_array_repeat(0, $q_index); + $temp->value[] = $quotient->value[$q_index]; + + $temp = $temp->multiply($y); + + if ( $x->compare($temp) < 0 ) + { + $corrector->value[] = 1; + $x = $x->add($corrector->multiply($y)); + $quotient->value[$q_index]--; + } + + $x = $x->subtract($temp); + $x_max = count($x->value) - 1; + } + + // unnormalize the remainder + $x->_rshift($shift); + + $quotient->is_negative = $x_sign != $y_sign; + + // calculate the "common residue", if appropriate + if ( $x_sign ) + { + $y->_rshift($shift); + $x = $y->subtract($x); + } + + return array($quotient->_normalize(), $x); + } + + /** + * Performs modular exponentiation. + * + * @param biginteger $e + * @param biginteger $n + * @return biginteger + * @access public + * @internal The most naive approach to modular exponentiation has very unreasonable requirements, and + * and although the approach involving repeated squaring does vastly better, it, too, is impractical + * for our purposes. The reason being that division - by far the most complicated and time-consuming + * of the basic operations (eg. +,-,*,/) - occurs multiple times within it. + * + * Modular reductions resolve this issue. Although an individual modular reduction takes more time + * then an individual division, when performed in succession (with the same modulo), they're a lot faster. + * + * The two most commonly used modular reductions are Barrett and Montgomery reduction. Montgomery reduction, + * although faster, only works when the gcd of the modulo and of the base being used is 1. In RSA, when the + * base is a power of two, the modulo - a product of two primes - is always going to have a gcd of 1 (because + * the product of two odd numbers is odd), but what about when RSA isn't used? + * + * In contrast, Barrett reduction has no such constraint. As such, some bigint implementations perform a + * Barrett reduction after every operation in the modpow function. Others perform Barrett reductions when the + * modulo is even and Montgomery reductions when the modulo is odd. BigInteger.java's modPow method, however, + * uses a trick involving the Chinese Remainder Theorem to factor the even modulo into two numbers - one odd and + * the other, a power of two - and recombine them, later. This is the method that this modPow function uses. + * {@link http://islab.oregonstate.edu/papers/j34monex.pdf Montgomery Reduction with Even Modulus} elaborates. + */ + function mod_pow($e, $n) + { + $n = $n->abs(); + if ($e->compare(new biginteger()) < 0) + { + $e = $e->abs(); + + $temp = $this->modInverse($n); + if ($temp === false) + { + return false; + } + + return $temp->modPow($e, $n); + } + + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = new biginteger(); + $temp->value = gmp_powm($this->value, $e->value, $n->value); + + return $temp; + case MATH_BIGINTEGER_MODE_BCMATH: + $temp = new biginteger(); + $temp->value = bcpowmod($this->value, $e->value, $n->value); + + return $temp; + } + + if ( empty($e->value) ) + { + $temp = new biginteger(); + $temp->value = array(1); + return $temp; + } + + if ( $e->value == array(1) ) + { + list(, $temp) = $this->divide($n); + return $temp; + } + + if ( $e->value == array(2) ) + { + $temp = $this->_square(); + list(, $temp) = $temp->divide($n); + return $temp; + } + + // is the modulo odd? + if ( $n->value[0] & 1 ) + { + return $this->_slidingWindow($e, $n, MATH_BIGINTEGER_MONTGOMERY); + } + // if it's not, it's even + + // find the lowest set bit (eg. the max pow of 2 that divides $n) + for ($i = 0; $i < count($n->value); $i++) + { + if ( $n->value[$i] ) + { + $temp = decbin($n->value[$i]); + $j = strlen($temp) - strrpos($temp, '1') - 1; + $j+= 26 * $i; + break; + } + } + // at this point, 2^$j * $n/(2^$j) == $n + + $mod1 = $n->_copy(); + $mod1->_rshift($j); + $mod2 = new biginteger(); + $mod2->value = array(1); + $mod2->_lshift($j); + + $part1 = ( $mod1->value != array(1) ) ? $this->_slidingWindow($e, $mod1, MATH_BIGINTEGER_MONTGOMERY) : new biginteger(); + $part2 = $this->_sliding_window($e, $mod2, MATH_BIGINTEGER_POWEROF2); + + $y1 = $mod2->mod_inverse($mod1); + $y2 = $mod1->mod_inverse($mod2); + + $result = $part1->multiply($mod2); + $result = $result->multiply($y1); + + $temp = $part2->multiply($mod1); + $temp = $temp->multiply($y2); + + $result = $result->add($temp); + list(, $result) = $result->divide($n); + + return $result; + } + + /** + * Sliding Window k-ary Modular Exponentiation + * + * Based on {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=27 HAC 14.85} / + * {@link http://math.libtomcrypt.com/files/tommath.pdf#page=210 MPM 7.7}. In a departure from those algorithims, + * however, this function performs a modular reduction after every multiplication and squaring operation. + * As such, this function has the same preconditions that the reductions being used do. + * + * @param biginteger $e + * @param biginteger $n + * @param Integer $mode + * @return biginteger + * @access private + */ + function _sliding_window($e, $n, $mode) + { + static $window_ranges = array(7, 25, 81, 241, 673, 1793); // from BigInteger.java's oddModPow function + //static $window_ranges = array(0, 7, 36, 140, 450, 1303, 3529); // from MPM 7.3.1 + + $e_length = count($e->value) - 1; + $e_bits = decbin($e->value[$e_length]); + for ($i = $e_length - 1; $i >= 0; $i--) + { + $e_bits.= str_pad(decbin($e->value[$i]), 26, '0', STR_PAD_LEFT); + } + $e_length = strlen($e_bits); + + // calculate the appropriate window size. + // $window_size == 3 if $window_ranges is between 25 and 81, for example. + for ($i = 0, $window_size = 1; $e_length > $window_ranges[$i] && $i < count($window_ranges); $window_size++, $i++); + + switch ($mode) + { + case MATH_BIGINTEGER_MONTGOMERY: + $reduce = '_montgomery'; + $undo = '_undo_montgomery'; + break; + case MATH_BIGINTEGER_BARRETT: + $reduce = '_barrett'; + $undo = '_barrett'; + break; + case MATH_BIGINTEGER_POWEROF2: + $reduce = '_mod2'; + $undo = '_mod2'; + break; + case MATH_BIGINTEGER_CLASSIC: + $reduce = '_remainder'; + $undo = '_remainder'; + break; + case MATH_BIGINTEGER_NONE: + // ie. do no modular reduction. useful if you want to just do pow as opposed to modPow. + $reduce = '_copy'; + $undo = '_copy'; + break; + default: + // an invalid $mode was provided + } + + // precompute $this^0 through $this^$window_size + $powers = array(); + $powers[1] = $this->$undo($n); + $powers[2] = $powers[1]->_square(); + $powers[2] = $powers[2]->$reduce($n); + + // we do every other number since substr($e_bits, $i, $j+1) (see below) is supposed to end + // in a 1. ie. it's supposed to be odd. + $temp = 1 << ($window_size - 1); + for ($i = 1; $i < $temp; $i++) + { + $powers[2 * $i + 1] = $powers[2 * $i - 1]->multiply($powers[2]); + $powers[2 * $i + 1] = $powers[2 * $i + 1]->$reduce($n); + } + + $result = new biginteger(); + $result->value = array(1); + $result = $result->$undo($n); + + for ($i = 0; $i < $e_length; ) + { + if ( !$e_bits[$i] ) + { + $result = $result->_square(); + $result = $result->$reduce($n); + $i++; + } + else + { + for ($j = $window_size - 1; $j >= 0; $j--) + { + if ( $e_bits[$i + $j] ) + { + break; + } + } + + for ($k = 0; $k <= $j; $k++) // eg. the length of substr($e_bits, $i, $j+1) + { + $result = $result->_square(); + $result = $result->$reduce($n); + } + + $result = $result->multiply($powers[bindec(substr($e_bits, $i, $j + 1))]); + $result = $result->$reduce($n); + + $i+=$j + 1; + } + } + + $result = $result->$reduce($n); + return $result->_normalize(); + } + + /** + * Remainder + * + * A wrapper for the divide function. + * + * @see divide() + * @see _slidingWindow() + * @access private + * @param biginteger + * @return biginteger + */ + function _remainder($n) + { + list(, $temp) = $this->divide($n); + return $temp; + } + + /** + * Modulos for Powers of Two + * + * Calculates $x%$n, where $n = 2**$e, for some $e. Since this is basically the same as doing $x & ($n-1), + * we'll just use this function as a wrapper for doing that. + * + * @see _slidingWindow() + * @access private + * @param biginteger + * @return biginteger + */ + function _mod2($n) + { + $temp = new biginteger(); + $temp->value = array(1); + return $this->bitwise_and($n->subtract($temp)); + } + + /** + * Barrett Modular Reduction + * + * See {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=14 HAC 14.3.3} / + * {@link http://math.libtomcrypt.com/files/tommath.pdf#page=165 MPM 6.2.5} for more information. Modified slightly, + * so as not to require negative numbers (initially, this script didn't support negative numbers). + * + * @see _slidingWindow() + * @access private + * @param biginteger + * @return biginteger + */ + function _barrett($n) + { + static $cache; + + $n_length = count($n->value); + + if ( !isset($cache[MATH_BIGINTEGER_VARIABLE]) || $n->compare($cache[MATH_BIGINTEGER_VARIABLE]) ) + { + $cache[MATH_BIGINTEGER_VARIABLE] = $n; + $temp = new biginteger(); + $temp->value = $this->_array_repeat(0, 2 * $n_length); + $temp->value[] = 1; + list($cache[MATH_BIGINTEGER_DATA], ) = $temp->divide($n); + } + + $temp = new biginteger(); + $temp->value = array_slice($this->value, $n_length - 1); + $temp = $temp->multiply($cache[MATH_BIGINTEGER_DATA]); + $temp->value = array_slice($temp->value, $n_length + 1); + + $result = new biginteger(); + $result->value = array_slice($this->value, 0, $n_length + 1); + $temp = $temp->multiply($n); + $temp->value = array_slice($temp->value, 0, $n_length + 1); + + if ($result->compare($temp) < 0) + { + $corrector = new biginteger(); + $corrector->value = $this->_array_repeat(0, $n_length + 1); + $corrector->value[] = 1; + $result = $result->add($corrector); + } + + $result = $result->subtract($temp); + while ($result->compare($n) > 0) + { + $result = $result->subtract($n); + } + + return $result; + } + + /** + * Montgomery Modular Reduction + * + * ($this->_montgomery($n))->_undoMontgomery($n) yields $x%$n. + * {@link http://math.libtomcrypt.com/files/tommath.pdf#page=170 MPM 6.3} provides insights on how this can be + * improved upon (basically, by using the comba method). gcd($n, 2) must be equal to one for this function + * to work correctly. + * + * @see _undoMontgomery() + * @see _slidingWindow() + * @access private + * @param biginteger + * @return biginteger + */ + function _montgomery($n) + { + static $cache; + + if ( !isset($cache[MATH_BIGINTEGER_VARIABLE]) || $n->compare($cache[MATH_BIGINTEGER_VARIABLE]) ) + { + $cache[MATH_BIGINTEGER_VARIABLE] = $n; + $cache[MATH_BIGINTEGER_DATA] = $n->_mod_inverse67108864(); + } + + $result = $this->_copy(); + + $n_length = count($n->value); + + for ($i = 0; $i < $n_length; $i++) + { + $temp = new biginteger(); + $temp->value = array( + ($result->value[$i] * $cache[MATH_BIGINTEGER_DATA]) & 0x3FFFFFF + ); + $temp = $temp->multiply($n); + $temp->value = array_merge($this->_array_repeat(0, $i), $temp->value); + $result = $result->add($temp); + } + + $result->value = array_slice($result->value, $n_length); + + if ($result->compare($n) >= 0) + { + $result = $result->subtract($n); + } + + return $result->_normalize(); + } + + /** + * Undo Montgomery Modular Reduction + * + * @see _montgomery() + * @see _slidingWindow() + * @access private + * @param biginteger + * @return biginteger + */ + function _undo_montgomery($n) + { + $temp = new biginteger(); + $temp->value = array_merge($this->_array_repeat(0, count($n->value)), $this->value); + list(, $temp) = $temp->divide($n); + return $temp->_normalize(); + } + + /** + * Modular Inverse of a number mod 2**26 (eg. 67108864) + * + * Based off of the bnpInvDigit function implemented and justified in the following URL: + * + * {@link http://www-cs-students.stanford.edu/~tjw/jsbn/jsbn.js} + * + * The following URL provides more info: + * + * {@link http://groups.google.com/group/sci.crypt/msg/7a137205c1be7d85} + * + * As for why we do all the bitmasking... strange things can happen when converting from floats to ints. For + * instance, on some computers, var_dump((int) -4294967297) yields int(-1) and on others, it yields + * int(-2147483648). To avoid problems stemming from this, we use bitmasks to guarantee that ints aren't + * auto-converted to floats. The outermost bitmask is present because without it, there's no guarantee that + * the "residue" returned would be the so-called "common residue". We use fmod, in the last step, because the + * maximum possible $x is 26 bits and the maximum $result is 16 bits. Thus, we have to be able to handle up to + * 40 bits, which only 64-bit floating points will support. + * + * Thanks to Pedro Gimeno Fortea for input! + * + * @see _montgomery() + * @access private + * @return Integer + */ + function _mod_inverse67108864() // 2**26 == 67108864 + { + $x = -$this->value[0]; + $result = $x & 0x3; // x**-1 mod 2**2 + $result = ($result * (2 - $x * $result)) & 0xF; // x**-1 mod 2**4 + $result = ($result * (2 - ($x & 0xFF) * $result)) & 0xFF; // x**-1 mod 2**8 + $result = ($result * ((2 - ($x & 0xFFFF) * $result) & 0xFFFF)) & 0xFFFF; // x**-1 mod 2**16 + $result = fmod($result * (2 - fmod($x * $result, 0x4000000)), 0x4000000); // x**-1 mod 2**26 + return $result & 0x3FFFFFF; + } + + /** + * Calculates modular inverses. + * + * @param biginteger $n + * @return mixed false, if no modular inverse exists, biginteger, otherwise. + * @access public + * @internal Calculates the modular inverse of $this mod $n using the binary xGCD algorithim described in + * {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=19 HAC 14.61}. As the text above 14.61 notes, + * the more traditional algorithim requires "relatively costly multiple-precision divisions". See + * {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=21 HAC 14.64} for more information. + */ + function mod_inverse($n) + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = new biginteger(); + $temp->value = gmp_invert($this->value, $n->value); + + return ( $temp->value === false ) ? false : $temp; + case MATH_BIGINTEGER_MODE_BCMATH: + // it might be faster to use the binary xGCD algorithim here, as well, but (1) that algorithim works + // best when the base is a power of 2 and (2) i don't think it'd make much difference, anyway. as is, + // the basic extended euclidean algorithim is what we're using. + + // if $x is less than 0, the first character of $x is a '-', so we'll remove it. we can do this because + // $x mod $n == $x mod -$n. + $n = (bccomp($n->value, '0') < 0) ? substr($n->value, 1) : $n->value; + + if (bccomp($this->value,'0') < 0) + { + $negated_this = new biginteger(); + $negated_this->value = substr($this->value, 1); + + $temp = $negated_this->mod_inverse(new biginteger($n)); + + if ($temp === false) + { + return false; + } + + $temp->value = bcsub($n, $temp->value); + + return $temp; + } + + $u = $this->value; + $v = $n; + + $a = '1'; + $c = '0'; + + while (true) + { + $q = bcdiv($u, $v); + $temp = $u; + $u = $v; + $v = bcsub($temp, bcmul($v, $q)); + + if (bccomp($v, '0') == 0) { + break; + } + + $temp = $a; + $a = $c; + $c = bcsub($temp, bcmul($c, $q)); + } + + $temp = new biginteger(); + $temp->value = (bccomp($c, '0') < 0) ? bcadd($c, $n) : $c; + + // $u contains the gcd of $this and $n + return (bccomp($u,'1') == 0) ? $temp : false; + } + + // if $this and $n are even, return false. + if ( !($this->value[0]&1) && !($n->value[0]&1) ) + { + return false; + } + + $n = $n->_copy(); + $n->is_negative = false; + + if ($this->compare(new biginteger()) < 0) + { + // is_negative is currently true. since we need it to be false, we'll just set it to false, temporarily, + // and reset it as true, later. + $this->is_negative = false; + + $temp = $this->mod_inverse($n); + + if ($temp === false) + { + return false; + } + + $temp = $n->subtract($temp); + + $this->is_negative = true; + + return $temp; + } + + $u = $n->_copy(); + $x = $this; + //list(, $x) = $this->divide($n); + $v = $x->_copy(); + + $a = new biginteger(); + $b = new biginteger(); + $c = new biginteger(); + $d = new biginteger(); + + $a->value = $d->value = array(1); + + while ( !empty($u->value) ) + { + while ( !($u->value[0] & 1) ) + { + $u->_rshift(1); + if ( ($a->value[0] & 1) || ($b->value[0] & 1) ) + { + $a = $a->add($x); + $b = $b->subtract($n); + } + $a->_rshift(1); + $b->_rshift(1); + } + + while ( !($v->value[0] & 1) ) + { + $v->_rshift(1); + if ( ($c->value[0] & 1) || ($d->value[0] & 1) ) + { + $c = $c->add($x); + $d = $d->subtract($n); + } + $c->_rshift(1); + $d->_rshift(1); + } + + if ($u->compare($v) >= 0) + { + $u = $u->subtract($v); + $a = $a->subtract($c); + $b = $b->subtract($d); + } + else + { + $v = $v->subtract($u); + $c = $c->subtract($a); + $d = $d->subtract($b); + } + + $u->_normalize(); + } + + // at this point, $v == gcd($this, $n). if it's not equal to 1, no modular inverse exists. + if ( $v->value != array(1) ) + { + return false; + } + + $d = ($d->compare(new biginteger()) < 0) ? $d->add($n) : $d; + + return ($this->is_negative) ? $n->subtract($d) : $d; + } + + /** + * Absolute value. + * + * @return biginteger + * @access public + */ + function abs() + { + $temp = new biginteger(); + + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp->value = gmp_abs($this->value); + break; + case MATH_BIGINTEGER_MODE_BCMATH: + $temp->value = (bccomp($this->value, '0') < 0) ? substr($this->value, 1) : $this->value; + break; + default: + $temp->value = $this->value; + } + + return $temp; + } + + /** + * Compares two numbers. + * + * @param biginteger $x + * @return Integer < 0 if $this is less than $x; > 0 if $this is greater than $x, and 0 if they are equal. + * @access public + * @internal Could return $this->sub($x), but that's not as fast as what we do do. + */ + function compare($x) + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + return gmp_cmp($this->value, $x->value); + case MATH_BIGINTEGER_MODE_BCMATH: + return bccomp($this->value, $x->value); + } + + $this->_normalize(); + $x->_normalize(); + + if ( $this->is_negative != $x->is_negative ) + { + return ( !$this->is_negative && $x->is_negative ) ? 1 : -1; + } + + $result = $this->is_negative ? -1 : 1; + + if ( count($this->value) != count($x->value) ) + { + return ( count($this->value) > count($x->value) ) ? $result : -$result; + } + + for ($i = count($this->value) - 1; $i >= 0; $i--) + { + if ($this->value[$i] != $x->value[$i]) + { + return ( $this->value[$i] > $x->value[$i] ) ? $result : -$result; + } + } + + return 0; + } + + /** + * Returns a copy of $this + * + * PHP5 passes objects by reference while PHP4 passes by value. As such, we need a function to guarantee + * that all objects are passed by value, when appropriate. More information can be found here: + * + * {@link http://www.php.net/manual/en/language.oop5.basic.php#51624} + * + * @access private + * @return biginteger + */ + function _copy() + { + $temp = new biginteger(); + $temp->value = $this->value; + $temp->is_negative = $this->is_negative; + return $temp; + } + + /** + * Logical And + * + * @param biginteger $x + * @access public + * @internal Implemented per a request by Lluis Pamies i Juarez + * @return biginteger + */ + function bitwise_and($x) + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = new biginteger(); + $temp->value = gmp_and($this->value, $x->value); + + return $temp; + case MATH_BIGINTEGER_MODE_BCMATH: + return new biginteger($this->to_bytes() & $x->to_bytes(), 256); + } + + $result = new biginteger(); + + $x_length = count($x->value); + for ($i = 0; $i < $x_length; $i++) + { + $result->value[] = $this->value[$i] & $x->value[$i]; + } + + return $result->_normalize(); + } + + /** + * Logical Or + * + * @param biginteger $x + * @access public + * @internal Implemented per a request by Lluis Pamies i Juarez + * @return biginteger + */ + function bitwise_or($x) + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = new biginteger(); + $temp->value = gmp_or($this->value, $x->value); + + return $temp; + case MATH_BIGINTEGER_MODE_BCMATH: + return new biginteger($this->to_bytes() | $x->to_bytes(), 256); + } + + $result = $this->_copy(); + + $x_length = count($x->value); + for ($i = 0; $i < $x_length; $i++) + { + $result->value[$i] = $this->value[$i] | $x->value[$i]; + } + + return $result->_normalize(); + } + + /** + * Logical Exclusive-Or + * + * @param biginteger $x + * @access public + * @internal Implemented per a request by Lluis Pamies i Juarez + * @return biginteger + */ + function bitwise_xor($x) + { + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + $temp = new biginteger(); + $temp->value = gmp_xor($this->value, $x->value); + + return $temp; + case MATH_BIGINTEGER_MODE_BCMATH: + return new biginteger($this->to_bytes() ^ $x->to_bytes(), 256); + } + + $result = $this->_copy(); + + $x_length = count($x->value); + for ($i = 0; $i < $x_length; $i++) + { + $result->value[$i] = $this->value[$i] ^ $x->value[$i]; + } + + return $result->_normalize(); + } + + /** + * Logical Not + * + * Although integers can be converted to and from various bases with relative ease, there is one piece + * of information that is lost during such conversions. The number of leading zeros that number had + * or should have in any given base. Per that, if you convert 1 from decimal to binary, there's no + * way to know just how many leading zero's there should be. In truth, there could be any number. + * + * Normally, the number of leading zero's is unimportant. When doing "not", however, it is. The "not" + * of 1 on an 8-bit representation of 1 is 1111 1110. The "not" of 1 on a 16-bit representation of 1 is + * 1111 1111 1111 1110. When doing it on a number that's preceeded by an infinite number of zero's, it's + * infinite. + * + * This function assumes that there are no leading zero's - that the bit-representation being used is + * equal to the minimum number of required bits, unless otherwise specified in the optional parameter, + * where the optional parameter represents the bit-representation being used. If the specified + * bit-representation is smaller than the minimum number of bits required to represent the number, the + * latter will be used as the bit-representation. + * + * @param $bits Integer + * @access public + * @internal Implemented per a request by Lluis Pamies i Juarez + * @return biginteger + */ + function bitwise_not($bits = -1) + { + // calculuate "not" without regard to $bits + $temp = ~$this->to_bytes(); + $msb = decbin(ord($temp[0])); + $msb = substr($msb, strpos($msb, '0')); + $temp[0] = chr(bindec($msb)); + + // see if we need to add extra leading 1's + $current_bits = strlen($msb) + 8 * strlen($temp) - 8; + $new_bits = $bits - $current_bits; + if ($new_bits <= 0) + { + return new biginteger($temp, 256); + } + + // generate as many leading 1's as we need to. + $leading_ones = chr((1 << ($new_bits & 0x7)) - 1) . str_repeat(chr(0xFF), $new_bits >> 3); + $this->_base256_lshift($leading_ones, $current_bits); + + $temp = str_pad($temp, ceil($bits / 8), chr(0), STR_PAD_LEFT); + + return new biginteger($leading_ones | $temp, 256); + } + + /** + * Logical Right Shift + * + * Shifts BigInteger's by $shift bits, effectively dividing by 2**$shift. + * + * @param Integer $shift + * @return biginteger + * @access public + * @internal The only version that yields any speed increases is the internal version. + */ + function bitwise_right_shift($shift) + { + $temp = new biginteger(); + + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + static $two; + + if (empty($two)) + { + $two = gmp_init('2'); + } + + $temp->value = gmp_div_q($this->value, gmp_pow($two, $shift)); + + break; + case MATH_BIGINTEGER_MODE_BCMATH: + $temp->value = bcdiv($this->value, bcpow('2', $shift)); + + break; + default: // could just replace _lshift with this, but then all _lshift() calls would need to be rewritten + // and I don't want to do that... + $temp->value = $this->value; + $temp->_rshift($shift); + } + + return $temp; + } + + /** + * Logical Left Shift + * + * Shifts BigInteger's by $shift bits, effectively multiplying by 2**$shift. + * + * @param Integer $shift + * @return biginteger + * @access public + * @internal The only version that yields any speed increases is the internal version. + */ + function bitwise_left_shift($shift) + { + $temp = new biginteger(); + + switch ( MATH_BIGINTEGER_MODE ) + { + case MATH_BIGINTEGER_MODE_GMP: + static $two; + + if (empty($two)) + { + $two = gmp_init('2'); + } + + $temp->value = gmp_mul($this->value, gmp_pow($two, $shift)); + + break; + case MATH_BIGINTEGER_MODE_BCMATH: + $temp->value = bcmul($this->value, bcpow('2', $shift)); + + break; + default: // could just replace _rshift with this, but then all _lshift() calls would need to be rewritten + // and I don't want to do that... + $temp->value = $this->value; + $temp->_lshift($shift); + } + + return $temp; + } + + /** + * Generate a random number + * + * $generator should be the name of a random number generating function whose first parameter is the minimum + * value and whose second parameter is the maximum value. If this function needs to be seeded, it should be + * done before this function is called. + * + * @param optional Integer $min + * @param optional Integer $max + * @param optional String $generator + * @return biginteger + * @access public + */ + function random($min = false, $max = false, $generator = 'mt_rand') + { + if ($min === false) + { + $min = new biginteger(0); + } + + if ($max === false) + { + $max = new biginteger(0x7FFFFFFF); + } + + $compare = $max->compare($min); + + if (!$compare) + { + return $min; + } + else if ($compare < 0) + { + // if $min is bigger then $max, swap $min and $max + $temp = $max; + $max = $min; + $min = $temp; + } + + $max = $max->subtract($min); + $max = ltrim($max->to_bytes(), chr(0)); + $size = strlen($max) - 1; + $random = ''; + + $bytes = $size & 3; + for ($i = 0; $i < $bytes; $i++) + { + $random.= chr($generator(0, 255)); + } + + $blocks = $size >> 2; + for ($i = 0; $i < $blocks; $i++) + { + $random.= pack('N', $generator(-2147483648, 0x7FFFFFFF)); + } + + $temp = new biginteger($random, 256); + if ($temp->compare(new biginteger(substr($max, 1), 256)) > 0) + { + $random = chr($generator(0, ord($max[0]) - 1)) . $random; + } + else + { + $random = chr($generator(0, ord($max[0]) )) . $random; + } + + $random = new biginteger($random, 256); + + return $random->add($min); + } + + /** + * Logical Left Shift + * + * Shifts BigInteger's by $shift bits. + * + * @param Integer $shift + * @access private + */ + function _lshift($shift) + { + if ( $shift == 0 ) + { + return; + } + + $num_digits = floor($shift / 26); + $shift %= 26; + $shift = 1 << $shift; + + $carry = 0; + + for ($i = 0; $i < count($this->value); $i++) + { + $temp = $this->value[$i] * $shift + $carry; + $carry = floor($temp / 0x4000000); + $this->value[$i] = $temp - $carry * 0x4000000; + } + + if ( $carry ) + { + $this->value[] = $carry; + } + + while ($num_digits--) + { + array_unshift($this->value, 0); + } + } + + /** + * Logical Right Shift + * + * Shifts BigInteger's by $shift bits. + * + * @param Integer $shift + * @access private + */ + function _rshift($shift) + { + if ($shift == 0) + { + $this->_normalize(); + } + + $num_digits = floor($shift / 26); + $shift %= 26; + $carry_shift = 26 - $shift; + $carry_mask = (1 << $shift) - 1; + + if ( $num_digits ) + { + $this->value = array_slice($this->value, $num_digits); + } + + $carry = 0; + + for ($i = count($this->value) - 1; $i >= 0; $i--) + { + $temp = $this->value[$i] >> $shift | $carry; + $carry = ($this->value[$i] & $carry_mask) << $carry_shift; + $this->value[$i] = $temp; + } + + $this->_normalize(); + } + + /** + * Normalize + * + * Deletes leading zeros. + * + * @see divide() + * @return Math_BigInteger + * @access private + */ + function _normalize() + { + if ( !count($this->value) ) + { + return $this; + } + + for ($i=count($this->value) - 1; $i >= 0; $i--) + { + if ( $this->value[$i] ) + { + break; + } + unset($this->value[$i]); + } + + return $this; + } + + /** + * Array Repeat + * + * @param $input Array + * @param $multiplier mixed + * @return Array + * @access private + */ + function _array_repeat($input, $multiplier) + { + return ($multiplier) ? array_fill(0, $multiplier, $input) : array(); + } + + /** + * Logical Left Shift + * + * Shifts binary strings $shift bits, essentially multiplying by 2**$shift. + * + * @param $x String + * @param $shift Integer + * @return String + * @access private + */ + function _base256_lshift(&$x, $shift) + { + if ($shift == 0) + { + return; + } + + $num_bytes = $shift >> 3; // eg. floor($shift/8) + $shift &= 7; // eg. $shift % 8 + + $carry = 0; + for ($i = strlen($x) - 1; $i >= 0; $i--) + { + $temp = ord($x[$i]) << $shift | $carry; + $x[$i] = chr($temp); + $carry = $temp >> 8; + } + $carry = ($carry != 0) ? chr($carry) : ''; + $x = $carry . $x . str_repeat(chr(0), $num_bytes); + } + + /** + * Logical Right Shift + * + * Shifts binary strings $shift bits, essentially dividing by 2**$shift and returning the remainder. + * + * @param $x String + * @param $shift Integer + * @return String + * @access private + */ + function _base256_rshift(&$x, $shift) + { + if ($shift == 0) + { + $x = ltrim($x, chr(0)); + return ''; + } + + $num_bytes = $shift >> 3; // eg. floor($shift/8) + $shift &= 7; // eg. $shift % 8 + + $remainder = ''; + if ($num_bytes) + { + $start = $num_bytes > strlen($x) ? -strlen($x) : -$num_bytes; + $remainder = substr($x, $start); + $x = substr($x, 0, -$num_bytes); + } + + $carry = 0; + $carry_shift = 8 - $shift; + for ($i = 0; $i < strlen($x); $i++) + { + $temp = (ord($x[$i]) >> $shift) | $carry; + $carry = (ord($x[$i]) << $carry_shift) & 0xFF; + $x[$i] = chr($temp); + } + $x = ltrim($x, chr(0)); + + $remainder = chr($carry >> $carry_shift) . $remainder; + + return ltrim($remainder, chr(0)); + } + + // one quirk about how the following functions are implemented is that PHP defines N to be an unsigned long + // at 32-bits, while java's longs are 64-bits. + + /** + * Converts 32-bit integers to bytes. + * + * @param Integer $x + * @return String + * @access private + */ + function _int2bytes($x) + { + return ltrim(pack('N', $x), chr(0)); + } + + /** + * Converts bytes to 32-bit integers + * + * @param String $x + * @return Integer + * @access private + */ + function _bytes2int($x) + { + $temp = unpack('Nint', str_pad($x, 4, chr(0), STR_PAD_LEFT)); + return $temp['int']; + } +} + +?> \ No newline at end of file -- cgit v1.2.1