mirror of
https://github.com/phpseclib/phpseclib.git
synced 2024-09-28 07:09:01 +00:00
BigInteger: modularize / modernize class and add new powmod engines
This commit is contained in:
terrafrost
parent
6a7e0210bc
commit
5fe629a171
File diff suppressed because it is too large
Load Diff
677
phpseclib/Math/BigInteger/Engines/BCMath.php
Normal file
677
phpseclib/Math/BigInteger/Engines/BCMath.php
Normal file
@ -0,0 +1,677 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* BCMath BigInteger Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines;
|
||||
|
||||
use ParagonIE\ConstantTime\Hex;
|
||||
use phpseclib\Exception\BadConfigurationException;
|
||||
|
||||
/**
|
||||
* BCMath Engine.
|
||||
*
|
||||
* @package BCMath
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
class BCMath extends Engine
|
||||
{
|
||||
/**
|
||||
* Can Bitwise operations be done fast?
|
||||
*
|
||||
* @see parent::bitwise_leftRotate()
|
||||
* @see parent::bitwise_rightRotate()
|
||||
* @access protected
|
||||
*/
|
||||
const FAST_BITWISE = false;
|
||||
|
||||
/**
|
||||
* Engine Directory
|
||||
*
|
||||
* @see parent::setModExpEngine
|
||||
* @access protected
|
||||
*/
|
||||
const ENGINE_DIR = 'BCMath';
|
||||
|
||||
/**
|
||||
* Modular Exponentiation Engine
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected static $modexpEngine;
|
||||
|
||||
/**
|
||||
* Engine Validity Flag
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
protected static $isValidEngine;
|
||||
|
||||
/**
|
||||
* BigInteger(0)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
protected static $zero;
|
||||
|
||||
/**
|
||||
* BigInteger(1)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
protected static $one;
|
||||
|
||||
/**
|
||||
* BigInteger(2)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
protected static $two;
|
||||
|
||||
/**
|
||||
* Primes > 2 and < 1000
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $primes;
|
||||
|
||||
/**
|
||||
* Test for engine validity
|
||||
*
|
||||
* @see parent::__construct()
|
||||
* @return bool
|
||||
*/
|
||||
public static function isValidEngine()
|
||||
{
|
||||
return extension_loaded('bcmath');
|
||||
}
|
||||
|
||||
/**
|
||||
* Default constructor
|
||||
*
|
||||
* @param $x base-10 number or base-$base number if $base set.
|
||||
* @param int $base
|
||||
* @see parent::__construct()
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function __construct($x = 0, $base = 10)
|
||||
{
|
||||
if (!isset(self::$isValidEngine)) {
|
||||
self::$isValidEngine = self::isValidEngine();
|
||||
}
|
||||
if (!self::$isValidEngine) {
|
||||
throw new BadConfigurationException('BCMath is not setup correctly on this system');
|
||||
}
|
||||
|
||||
$this->value = '0';
|
||||
|
||||
parent::__construct($x, $base);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize a BCMath BigInteger Engine instance
|
||||
*
|
||||
* @param int $base
|
||||
* @see parent::__construct()
|
||||
*/
|
||||
protected function initialize($base)
|
||||
{
|
||||
switch (abs($base)) {
|
||||
case 256:
|
||||
// round $len to the nearest 4
|
||||
$len = (strlen($this->value) + 3) & 0xFFFFFFFC;
|
||||
|
||||
$x = str_pad($this->value, $len, chr(0), STR_PAD_LEFT);
|
||||
|
||||
$this->value = '0';
|
||||
for ($i = 0; $i < $len; $i+= 4) {
|
||||
$this->value = bcmul($this->value, '4294967296', 0); // 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])), 0);
|
||||
}
|
||||
|
||||
if ($this->is_negative) {
|
||||
$this->value = '-' . $this->value;
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
$x = (strlen($this->value) & 1) ? '0' . $this->value : $this->value;
|
||||
$temp = new self(Hex::decode($x), 256);
|
||||
$this->value = $this->is_negative ? '-' . $temp->value : $temp->value;
|
||||
$this->is_negative = false;
|
||||
break;
|
||||
case 10:
|
||||
// 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 = $this->value === '-' ? '0' : (string) $this->value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a BigInteger to a base-10 number.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function toString()
|
||||
{
|
||||
if ($this->value === '0') {
|
||||
return '0';
|
||||
}
|
||||
|
||||
return ltrim($this->value, '0');
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a BigInteger to a byte string (eg. base-256).
|
||||
*
|
||||
* @param bool $twos_compliment
|
||||
* @return string
|
||||
*/
|
||||
function toBytes($twos_compliment = false)
|
||||
{
|
||||
if ($twos_compliment) {
|
||||
return $this->toBytesHelper();
|
||||
}
|
||||
|
||||
$value = '';
|
||||
$current = $this->value;
|
||||
|
||||
if ($current[0] == '-') {
|
||||
$current = substr($current, 1);
|
||||
}
|
||||
|
||||
while (bccomp($current, '0', 0) > 0) {
|
||||
$temp = bcmod($current, '16777216');
|
||||
$value = chr($temp >> 16) . chr($temp >> 8) . chr($temp) . $value;
|
||||
$current = bcdiv($current, '16777216', 0);
|
||||
}
|
||||
|
||||
return $this->precision > 0 ?
|
||||
substr(str_pad($value, $this->precision >> 3, chr(0), STR_PAD_LEFT), -($this->precision >> 3)) :
|
||||
ltrim($value, chr(0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function add(BCMath $y)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = bcadd($this->value, $y->value);
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function subtract(BCMath $y)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = bcsub($this->value, $y->value);
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Multiplies two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function multiply(BCMath $x)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = bcmul($this->value, $x->value);
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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).
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function divide(BCMath $y)
|
||||
{
|
||||
$quotient = new self();
|
||||
$remainder = new self();
|
||||
|
||||
$quotient->value = bcdiv($this->value, $y->value, 0);
|
||||
$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, 0);
|
||||
}
|
||||
|
||||
return [$this->normalize($quotient), $this->normalize($remainder)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates modular inverses.
|
||||
*
|
||||
* Say you have (30 mod 17 * x mod 17) mod 17 == 1. x can be found using modular inverses.
|
||||
*
|
||||
* @param \phpseclib\Math\BigInteger\Engines\BCMath $n
|
||||
*/
|
||||
public function modInverse(BCMath $n)
|
||||
{
|
||||
return $this->modInverseHelper($n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the greatest common divisor and Bezout's identity.
|
||||
*
|
||||
* Say you have 693 and 609. The GCD is 21. Bezout's identity states that there exist integers x and y such that
|
||||
* 693*x + 609*y == 21. In point of fact, there are actually an infinite number of x and y combinations and which
|
||||
* combination is returned is dependent upon which mode is in use. See
|
||||
* {@link http://en.wikipedia.org/wiki/B%C3%A9zout%27s_identity Bezout's identity - Wikipedia} for more information.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function extendedGCD(BCMath $n)
|
||||
{
|
||||
// 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.
|
||||
|
||||
$u = $this->value;
|
||||
$v = $n->value;
|
||||
|
||||
$a = '1';
|
||||
$b = '0';
|
||||
$c = '0';
|
||||
$d = '1';
|
||||
|
||||
while (bccomp($v, '0', 0) != 0) {
|
||||
$q = bcdiv($u, $v, 0);
|
||||
|
||||
$temp = $u;
|
||||
$u = $v;
|
||||
$v = bcsub($temp, bcmul($v, $q, 0), 0);
|
||||
|
||||
$temp = $a;
|
||||
$a = $c;
|
||||
$c = bcsub($temp, bcmul($a, $q, 0), 0);
|
||||
|
||||
$temp = $b;
|
||||
$b = $d;
|
||||
$d = bcsub($temp, bcmul($b, $q, 0), 0);
|
||||
}
|
||||
|
||||
return [
|
||||
'gcd' => $this->normalize(new static($u)),
|
||||
'x' => $this->normalize(new static($a)),
|
||||
'y' => $this->normalize(new static($b))
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the greatest common divisor
|
||||
*
|
||||
* Say you have 693 and 609. The GCD is 21.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function gcd(BCMath $n)
|
||||
{
|
||||
extract($this->extendedGCD($n));
|
||||
return $gcd;
|
||||
}
|
||||
|
||||
/**
|
||||
* Absolute value.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function abs()
|
||||
{
|
||||
$temp = new static();
|
||||
$temp->value = bccomp($this->value, '0', 0) < 0 ?
|
||||
substr($this->value, 1) :
|
||||
$this->value;
|
||||
|
||||
return $temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical And
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function bitwise_and(BCMath $x)
|
||||
{
|
||||
$left = $this->toBytes();
|
||||
$right = $x->toBytes();
|
||||
|
||||
$length = max(strlen($left), strlen($right));
|
||||
|
||||
$left = str_pad($left, $length, chr(0), STR_PAD_LEFT);
|
||||
$right = str_pad($right, $length, chr(0), STR_PAD_LEFT);
|
||||
|
||||
return $this->normalize(new static($left & $right, 256));
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Or
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function bitwise_or(BCMath $x)
|
||||
{
|
||||
$left = $this->toBytes();
|
||||
$right = $x->toBytes();
|
||||
|
||||
$length = max(strlen($left), strlen($right));
|
||||
|
||||
$left = str_pad($left, $length, chr(0), STR_PAD_LEFT);
|
||||
$right = str_pad($right, $length, chr(0), STR_PAD_LEFT);
|
||||
|
||||
return $this->normalize(new static($left | $right, 256));
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Exlusive Or
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function bitwise_xor(BCMath $x)
|
||||
{
|
||||
$left = $this->toBytes();
|
||||
$right = $x->toBytes();
|
||||
|
||||
$length = max(strlen($left), strlen($right));
|
||||
|
||||
$left = str_pad($left, $length, chr(0), STR_PAD_LEFT);
|
||||
$right = str_pad($right, $length, chr(0), STR_PAD_LEFT);
|
||||
|
||||
return $this->normalize(new static($left ^ $right, 256));
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Right Shift
|
||||
*
|
||||
* Shifts BigInteger's by $shift bits, effectively dividing by 2**$shift.
|
||||
*
|
||||
* @param int $shift
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function bitwise_rightShift($shift)
|
||||
{
|
||||
$temp = new static();
|
||||
$temp->value = bcdiv($this->value, bcpow('2', $shift, 0), 0);
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Left Shift
|
||||
*
|
||||
* Shifts BigInteger's by $shift bits, effectively multiplying by 2**$shift.
|
||||
*
|
||||
* @param int $shift
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function bitwise_leftShift($shift)
|
||||
{
|
||||
$temp = new static();
|
||||
$temp->value = bcmul($this->value, bcpow('2', $shift, 0), 0);
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares two numbers.
|
||||
*
|
||||
* Although one might think !$x->compare($y) means $x != $y, it, in fact, means the opposite. The reason for this is
|
||||
* demonstrated thusly:
|
||||
*
|
||||
* $x > $y: $x->compare($y) > 0
|
||||
* $x < $y: $x->compare($y) < 0
|
||||
* $x == $y: $x->compare($y) == 0
|
||||
*
|
||||
* Note how the same comparison operator is used. If you want to test for equality, use $x->equals($y).
|
||||
*
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @return int < 0 if $this is less than $y; > 0 if $this is greater than $y, and 0 if they are equal.
|
||||
* @see self::equals()
|
||||
* @internal Could return $this->subtract($x), but that's not as fast as what we do do.
|
||||
*/
|
||||
public function compare(BCMath $y)
|
||||
{
|
||||
return bccomp($this->value, $y->value, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the equality of two numbers.
|
||||
*
|
||||
* If you need to see if one number is greater than or less than another number, use BigInteger::compare()
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function equals(BCMath $x)
|
||||
{
|
||||
return $this->value == $x->value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function modPow(BCMath $e, BCMath $n)
|
||||
{
|
||||
return $this->powModOuter($e, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* Alias for modPow().
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function powMod(BCMath $e, BCMath $n)
|
||||
{
|
||||
return $this->powModOuter($e, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
protected function powModInner(BCMath $e, BCMath $n)
|
||||
{
|
||||
try {
|
||||
$class = self::$modexpEngine;
|
||||
return $class::powModHelper($this, $e, $n, static::class);
|
||||
} catch (\Exception $err) {
|
||||
return BCMath\DefaultEngine::powModHelper($this, $e, $n, static::class);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalize
|
||||
*
|
||||
* Removes leading zeros and truncates (if necessary) to maintain the appropriate precision
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
protected function normalize(BCMath $result)
|
||||
{
|
||||
$result->precision = $this->precision;
|
||||
$result->bitmask = $this->bitmask;
|
||||
|
||||
if ($result->bitmask !== false) {
|
||||
$result->value = bcmod($result->value, $result->bitmask->value);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random prime number between a range
|
||||
*
|
||||
* If there's not a prime within the given range, false will be returned.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath|false
|
||||
*/
|
||||
public static function randomRangePrime(BCMath $min, BCMath $max)
|
||||
{
|
||||
return self::randomRangePrimeOuter($min, $max);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random number between a range
|
||||
*
|
||||
* Returns a random number between $min and $max where $min and $max
|
||||
* can be defined using one of the two methods:
|
||||
*
|
||||
* BigInteger::randomRange($min, $max)
|
||||
* BigInteger::randomRange($max, $min)
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\Engine\BCMath
|
||||
*/
|
||||
public static function randomRange(BCMath $min, BCMath $max)
|
||||
{
|
||||
return self::randomRangeHelper($min, $max);
|
||||
}
|
||||
|
||||
/**
|
||||
* Make the current number odd
|
||||
*
|
||||
* If the current number is odd it'll be unchanged. If it's even, one will be added to it.
|
||||
*
|
||||
* @see self::randomPrime()
|
||||
*/
|
||||
protected function make_odd()
|
||||
{
|
||||
if ($this->value[strlen($this->value) - 1] % 2 == 0) {
|
||||
$this->value = bcadd($this->value, '1');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the number against small primes.
|
||||
*
|
||||
* @see self::isPrime()
|
||||
*/
|
||||
protected function testSmallPrimes()
|
||||
{
|
||||
if ($this->value === '1') {
|
||||
return false;
|
||||
}
|
||||
if ($this->value === '2') {
|
||||
return true;
|
||||
}
|
||||
if ($this->value[strlen($this->value) - 1] % 2 == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$value = $this->value;
|
||||
|
||||
foreach (self::$primes as $prime) {
|
||||
$r = bcmod($this->value, $prime);
|
||||
if ($r == '0') {
|
||||
return $this->value == $prime;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan for 1 and right shift by that amount
|
||||
*
|
||||
* ie. $s = gmp_scan1($n, 0) and $r = gmp_div_q($n, gmp_pow(gmp_init('2'), $s));
|
||||
*
|
||||
* @see self::isPrime()
|
||||
* @return int
|
||||
*/
|
||||
protected static function scan1divide($r)
|
||||
{
|
||||
$r_value = &$r->value;
|
||||
$s = 0;
|
||||
// if $n was 1, $r would be 0 and this would be an infinite loop, hence our $this->equals(static::$one) check earlier
|
||||
while ($r_value[strlen($r_value) - 1] % 2 == 0) {
|
||||
$r_value = bcdiv($r_value, '2', 0);
|
||||
++$s;
|
||||
}
|
||||
|
||||
return $s;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public function pow(BCMath $n)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = bcpow($this->value, $n->value);
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the minimum BigInteger between an arbitrary number of BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public static function min(BCMath ...$nums)
|
||||
{
|
||||
return self::minHelper($nums);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the maximum BigInteger between an arbitrary number of BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
public static function max(BCMath ...$nums)
|
||||
{
|
||||
return self::maxHelper($nums);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests BigInteger to see if it is between two integers, inclusive
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function between(BCMath $min, BCMath $max)
|
||||
{
|
||||
return $this->compare($min) >= 0 && $this->compare($max) <= 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Bitmask
|
||||
*
|
||||
* @param int $bits
|
||||
* @see self::setPrecision()
|
||||
*/
|
||||
protected static function setBitmask($bits)
|
||||
{
|
||||
$temp = parent::setBitmask($bits);
|
||||
return $temp->add(static::$one);
|
||||
}
|
||||
}
|
||||
121
phpseclib/Math/BigInteger/Engines/BCMath/Base.php
Normal file
121
phpseclib/Math/BigInteger/Engines/BCMath/Base.php
Normal file
@ -0,0 +1,121 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\BCMath;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\BCMath;
|
||||
|
||||
/**
|
||||
* Sliding Window Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Base extends BCMath
|
||||
{
|
||||
/**#@+
|
||||
* @access private
|
||||
*/
|
||||
/**
|
||||
* Cache constants
|
||||
*
|
||||
* $cache[self::VARIABLE] tells us whether or not the cached data is still valid.
|
||||
*/
|
||||
const VARIABLE = 0;
|
||||
/**
|
||||
* $cache[self::DATA] contains the cached data.
|
||||
*/
|
||||
const DATA = 1;
|
||||
/**#@-*/
|
||||
|
||||
/**
|
||||
* Test for engine validity
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public static function isValidEngine()
|
||||
{
|
||||
return static::class != __CLASS__;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @param \phpseclib\Math\BigInteger\Engines\BCMath $x
|
||||
* @param \phpseclib\Math\BigInteger\Engines\BCMath $e
|
||||
* @param \phpseclib\Math\BigInteger\Engines\BCMath $n
|
||||
* @param string $class
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
protected static function powModHelper(BCMath $x, BCMath $e, BCMath $n, $class)
|
||||
{
|
||||
if (empty($e->value)) {
|
||||
$temp = new $class();
|
||||
$temp->value = '1';
|
||||
return $x->normalize($temp);
|
||||
}
|
||||
|
||||
if ($e->value == '1') {
|
||||
$temp = bcdiv($x, $n);
|
||||
return $x->normalize($temp);
|
||||
}
|
||||
|
||||
return $x->normalize(static::slidingWindow($x, $e, $n, $class));
|
||||
}
|
||||
|
||||
/**
|
||||
* Modular reduction preperation
|
||||
*
|
||||
* @param string $x
|
||||
* @param string $n
|
||||
* @param string $class
|
||||
* @see self::slidingWindow()
|
||||
* @return string
|
||||
*/
|
||||
protected static function prepareReduce($x, $n, $class)
|
||||
{
|
||||
return static::reduce($x, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Modular multiply
|
||||
*
|
||||
* @param string $x
|
||||
* @param string $y
|
||||
* @param string $n
|
||||
* @param string $class
|
||||
* @see self::slidingWindow()
|
||||
* @return string
|
||||
*/
|
||||
protected static function multiplyReduce($x, $y, $n, $class)
|
||||
{
|
||||
return static::reduce(bcmul($x, $y), $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Modular square
|
||||
*
|
||||
* @param string $x
|
||||
* @param string $n
|
||||
* @param string $class
|
||||
* @see self::slidingWindow()
|
||||
* @return string
|
||||
*/
|
||||
protected static function squareReduce($x, $n, $class)
|
||||
{
|
||||
return static::reduce(bcmul($x, $x), $n);
|
||||
}
|
||||
}
|
||||
41
phpseclib/Math/BigInteger/Engines/BCMath/BuiltIn.php
Normal file
41
phpseclib/Math/BigInteger/Engines/BCMath/BuiltIn.php
Normal file
@ -0,0 +1,41 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Built-In BCMath Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\BCMath;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\BCMath;
|
||||
|
||||
/**
|
||||
* Built-In BCMath Modular Exponentiation Engine
|
||||
*
|
||||
* @package BCMath
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class BuiltIn extends BCMath
|
||||
{
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\BCMath
|
||||
*/
|
||||
protected static function powModHelper(BCMath $x, BCMath $e, BCMath $n)
|
||||
{
|
||||
$temp = new BCMath();
|
||||
$temp->value = bcpowmod($x->value, $e->value, $n->value);
|
||||
|
||||
return $x->normalize($temp);
|
||||
}
|
||||
}
|
||||
29
phpseclib/Math/BigInteger/Engines/BCMath/DefaultEngine.php
Normal file
29
phpseclib/Math/BigInteger/Engines/BCMath/DefaultEngine.php
Normal file
@ -0,0 +1,29 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* BCMath Default Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\BCMath;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\BCMath\Reductions\Barrett;
|
||||
|
||||
/**
|
||||
* PHP Default Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class DefaultEngine extends Barrett
|
||||
{
|
||||
}
|
||||
29
phpseclib/Math/BigInteger/Engines/BCMath/OpenSSL.php
Normal file
29
phpseclib/Math/BigInteger/Engines/BCMath/OpenSSL.php
Normal file
@ -0,0 +1,29 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* OpenSSL Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\BCMath;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\OpenSSL as Progenitor;
|
||||
|
||||
/**
|
||||
* OpenSSL Modular Exponentiation Engine
|
||||
*
|
||||
* @package BCMath
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class OpenSSL extends Progenitor
|
||||
{
|
||||
}
|
||||
193
phpseclib/Math/BigInteger/Engines/BCMath/Reductions/Barrett.php
Normal file
193
phpseclib/Math/BigInteger/Engines/BCMath/Reductions/Barrett.php
Normal file
@ -0,0 +1,193 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* BCMath Barrett Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\BCMath\Reductions;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\BCMath\Base;
|
||||
|
||||
/**
|
||||
* PHP Barrett Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Barrett extends Base
|
||||
{
|
||||
/**#@+
|
||||
* @access private
|
||||
*/
|
||||
/**
|
||||
* Cache constants
|
||||
*
|
||||
* $cache[self::VARIABLE] tells us whether or not the cached data is still valid.
|
||||
*/
|
||||
const VARIABLE = 0;
|
||||
/**
|
||||
* $cache[self::DATA] contains the cached data.
|
||||
*/
|
||||
const DATA = 1;
|
||||
/**#@-*/
|
||||
|
||||
/**
|
||||
* 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).
|
||||
*
|
||||
* Employs "folding", as described at
|
||||
* {@link http://www.cosic.esat.kuleuven.be/publications/thesis-149.pdf#page=66 thesis-149.pdf#page=66}. To quote from
|
||||
* it, "the idea [behind folding] is to find a value x' such that x (mod m) = x' (mod m), with x' being smaller than x."
|
||||
*
|
||||
* Unfortunately, the "Barrett Reduction with Folding" algorithm described in thesis-149.pdf is not, as written, all that
|
||||
* usable on account of (1) its not using reasonable radix points as discussed in
|
||||
* {@link http://math.libtomcrypt.com/files/tommath.pdf#page=162 MPM 6.2.2} and (2) the fact that, even with reasonable
|
||||
* radix points, it only works when there are an even number of digits in the denominator. The reason for (2) is that
|
||||
* (x >> 1) + (x >> 1) != x / 2 + x / 2. If x is even, they're the same, but if x is odd, they're not. See the in-line
|
||||
* comments for details.
|
||||
*
|
||||
* @param string $n
|
||||
* @param string $m
|
||||
* @return array
|
||||
*/
|
||||
protected static function reduce($n, $m)
|
||||
{
|
||||
static $cache = [
|
||||
self::VARIABLE => [],
|
||||
self::DATA => []
|
||||
];
|
||||
|
||||
$m_length = strlen($m);
|
||||
|
||||
if (strlen($n) > 2 * $m_length) {
|
||||
return bcmod($n, $m);
|
||||
}
|
||||
|
||||
// if (m.length >> 1) + 2 <= m.length then m is too small and n can't be reduced
|
||||
if ($m_length < 5) {
|
||||
return self::regularBarrett($n, $m);
|
||||
}
|
||||
// n = 2 * m.length
|
||||
|
||||
if (($key = array_search($m, $cache[self::VARIABLE])) === false) {
|
||||
$key = count($cache[self::VARIABLE]);
|
||||
$cache[self::VARIABLE][] = $m;
|
||||
|
||||
$lhs = '1' . str_repeat('0', $m_length + ($m_length >> 1));
|
||||
$u = bcdiv($lhs, $m, 0);
|
||||
$m1 = bcsub($lhs, bcmul($u, $m));
|
||||
|
||||
$cache[self::DATA][] = [
|
||||
'u' => $u, // m.length >> 1 (technically (m.length >> 1) + 1)
|
||||
'm1'=> $m1 // m.length
|
||||
];
|
||||
} else {
|
||||
extract($cache[self::DATA][$key]);
|
||||
}
|
||||
|
||||
$cutoff = $m_length + ($m_length >> 1);
|
||||
|
||||
$lsd = substr($n, -$cutoff);
|
||||
$msd = substr($n, 0, -$cutoff);
|
||||
|
||||
$temp = bcmul($msd, $m1); // m.length + (m.length >> 1)
|
||||
$n = bcadd($lsd, $temp); // m.length + (m.length >> 1) + 1 (so basically we're adding two same length numbers)
|
||||
//if ($m_length & 1) {
|
||||
// return self::regularBarrett($n, $m);
|
||||
//}
|
||||
|
||||
// (m.length + (m.length >> 1) + 1) - (m.length - 1) == (m.length >> 1) + 2
|
||||
$temp = substr($n, 0, -$m_length + 1);
|
||||
// if even: ((m.length >> 1) + 2) + (m.length >> 1) == m.length + 2
|
||||
// if odd: ((m.length >> 1) + 2) + (m.length >> 1) == (m.length - 1) + 2 == m.length + 1
|
||||
$temp = bcmul($temp, $u);
|
||||
// if even: (m.length + 2) - ((m.length >> 1) + 1) = m.length - (m.length >> 1) + 1
|
||||
// if odd: (m.length + 1) - ((m.length >> 1) + 1) = m.length - (m.length >> 1)
|
||||
$temp = substr($temp, 0, -($m_length >> 1) - 1);
|
||||
// if even: (m.length - (m.length >> 1) + 1) + m.length = 2 * m.length - (m.length >> 1) + 1
|
||||
// if odd: (m.length - (m.length >> 1)) + m.length = 2 * m.length - (m.length >> 1)
|
||||
$temp = bcmul($temp, $m);
|
||||
|
||||
// at this point, if m had an odd number of digits, we'd be subtracting a 2 * m.length - (m.length >> 1) digit
|
||||
// number from a m.length + (m.length >> 1) + 1 digit number. ie. there'd be an extra digit and the while loop
|
||||
// following this comment would loop a lot (hence our calling _regularBarrett() in that situation).
|
||||
|
||||
$result = bcsub($n, $temp);
|
||||
|
||||
//if (bccomp($result, '0') < 0) {
|
||||
if ($result[0] == '-') {
|
||||
$temp = '1' . str_repeat('0', $m_length + 1);
|
||||
$result = bcadd($result, $temp);
|
||||
}
|
||||
|
||||
while (bccomp($result, $m) >= 0) {
|
||||
$result = bcsub($result, $m);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* (Regular) Barrett Modular Reduction
|
||||
*
|
||||
* For numbers with more than four digits BigInteger::_barrett() is faster. The difference between that and this
|
||||
* is that this function does not fold the denominator into a smaller form.
|
||||
*
|
||||
* @param string $x
|
||||
* @param string $n
|
||||
* @return string
|
||||
*/
|
||||
private static function regularBarrett($x, $n)
|
||||
{
|
||||
static $cache = [
|
||||
self::VARIABLE => [],
|
||||
self::DATA => []
|
||||
];
|
||||
|
||||
$n_length = strlen($n);
|
||||
|
||||
if (strlen($x) > 2 * $n_length) {
|
||||
return bcmod($x, $n);
|
||||
}
|
||||
|
||||
if (($key = array_search($n, $cache[self::VARIABLE])) === false) {
|
||||
$key = count($cache[self::VARIABLE]);
|
||||
$cache[self::VARIABLE][] = $n;
|
||||
$lhs = '1' . str_repeat('0', 2 * $n_length);
|
||||
$cache[self::DATA][] = bcdiv($lhs, $n, 0);
|
||||
}
|
||||
|
||||
$temp = substr($x, 0, -$n_length + 1);
|
||||
$temp = bcmul($temp, $cache[self::DATA][$key]);
|
||||
$temp = substr($temp, 0, -$n_length - 1);
|
||||
|
||||
$r1 = substr($x, -$n_length - 1);
|
||||
$r2 = substr(bcmul($temp, $n), -$n_length - 1);
|
||||
$result = bcsub($r1, $r2);
|
||||
|
||||
//if (bccomp($result, '0') < 0) {
|
||||
if ($result[0] == '-') {
|
||||
$q = '1' . str_repeat('0', $n_length + 1);
|
||||
$result = bcadd($result, $q);
|
||||
}
|
||||
|
||||
while (bccomp($result, $n) >= 0) {
|
||||
$result = bcsub($result, $n);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,110 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* BCMath Dynamic Barrett Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\BCMath\Reductions;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\BCMath\Base;
|
||||
use phpseclib\Math\BigInteger\Engines\BCMath;
|
||||
|
||||
/**
|
||||
* PHP Barrett Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class EvalBarrett extends Base
|
||||
{
|
||||
/**
|
||||
* Custom Reduction Function
|
||||
*
|
||||
* @see self::generateCustomReduction
|
||||
*/
|
||||
private static $custom_reduction;
|
||||
|
||||
/**
|
||||
* Barrett Modular Reduction
|
||||
*
|
||||
* This calls a dynamically generated loop unrolled function that's specific to a given modulo.
|
||||
* Array lookups are avoided as are if statements testing for how many bits the host OS supports, etc.
|
||||
*
|
||||
* @param string $n
|
||||
* @param string $m
|
||||
* @return string
|
||||
*/
|
||||
protected static function reduce($n, $m)
|
||||
{
|
||||
$inline = self::$custom_reduction;
|
||||
return $inline($n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate Custom Reduction
|
||||
*
|
||||
* @param array $m
|
||||
* @param string $class
|
||||
* @return callable
|
||||
*/
|
||||
protected static function generateCustomReduction(BCMath $m, $class)
|
||||
{
|
||||
$m_length = strlen($m);
|
||||
|
||||
if ($m_length < 5) {
|
||||
$code = 'return bcmod($x, $n);';
|
||||
eval('$func = function ($n) { ' . $code . '};');
|
||||
self::$custom_reduction = $func;
|
||||
return;
|
||||
}
|
||||
|
||||
$lhs = '1' . str_repeat('0', $m_length + ($m_length >> 1));
|
||||
$u = bcdiv($lhs, $m, 0);
|
||||
$m1 = bcsub($lhs, bcmul($u, $m));
|
||||
|
||||
$cutoff = $m_length + ($m_length >> 1);
|
||||
|
||||
$m = "'$m'";
|
||||
$u = "'$u'";
|
||||
$m1= "'$m1'";
|
||||
|
||||
$code.= '
|
||||
$lsd = substr($n, -' . $cutoff . ');
|
||||
$msd = substr($n, 0, -' . $cutoff . ');
|
||||
|
||||
$temp = bcmul($msd, ' . $m1 . ');
|
||||
$n = bcadd($lsd, $temp);
|
||||
|
||||
$temp = substr($n, 0, ' . (-$m_length + 1) . ');
|
||||
$temp = bcmul($temp, ' . $u . ');
|
||||
$temp = substr($temp, 0, ' . (-($m_length >> 1) - 1) . ');
|
||||
$temp = bcmul($temp, ' . $m . ');
|
||||
|
||||
$result = bcsub($n, $temp);
|
||||
|
||||
if ($result[0] == \'-\') {
|
||||
$temp = \'1' . str_repeat('0', $m_length + 1) . '\';
|
||||
$result = bcadd($result, $temp);
|
||||
}
|
||||
|
||||
while (bccomp($result, ' . $m . ') >= 0) {
|
||||
$result = bcsub($result, ' . $m . ');
|
||||
}
|
||||
|
||||
return $result;';
|
||||
|
||||
eval('$func = function ($n) { ' . $code . '};');
|
||||
|
||||
self::$custom_reduction = $func;
|
||||
}
|
||||
}
|
||||
1039
phpseclib/Math/BigInteger/Engines/Engine.php
Normal file
1039
phpseclib/Math/BigInteger/Engines/Engine.php
Normal file
File diff suppressed because it is too large
Load Diff
600
phpseclib/Math/BigInteger/Engines/GMP.php
Normal file
600
phpseclib/Math/BigInteger/Engines/GMP.php
Normal file
@ -0,0 +1,600 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* GMP BigInteger Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines;
|
||||
|
||||
use ParagonIE\ConstantTime\Hex;
|
||||
use phpseclib\Exception\BadConfigurationException;
|
||||
|
||||
/**
|
||||
* GMP Engine.
|
||||
*
|
||||
* @package GMP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
class GMP extends Engine
|
||||
{
|
||||
/**
|
||||
* Can Bitwise operations be done fast?
|
||||
*
|
||||
* @see parent::bitwise_leftRotate()
|
||||
* @see parent::bitwise_rightRotate()
|
||||
* @access protected
|
||||
*/
|
||||
const FAST_BITWISE = true;
|
||||
|
||||
/**
|
||||
* Engine Directory
|
||||
*
|
||||
* @see parent::setModExpEngine
|
||||
* @access protected
|
||||
*/
|
||||
const ENGINE_DIR = 'GMP';
|
||||
|
||||
/**
|
||||
* Modular Exponentiation Engine
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected static $modexpEngine;
|
||||
|
||||
/**
|
||||
* Engine Validity Flag
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
protected static $isValidEngine;
|
||||
|
||||
/**
|
||||
* BigInteger(0)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
protected static $zero;
|
||||
|
||||
/**
|
||||
* BigInteger(1)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
protected static $one;
|
||||
|
||||
/**
|
||||
* BigInteger(2)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
protected static $two;
|
||||
|
||||
/**
|
||||
* Primes > 2 and < 1000
|
||||
*
|
||||
* Unused for GMP Engine
|
||||
*
|
||||
* @var mixed
|
||||
*/
|
||||
protected static $primes;
|
||||
|
||||
/**
|
||||
* Test for engine validity
|
||||
*
|
||||
* @see parent::__construct()
|
||||
* @return bool
|
||||
*/
|
||||
public static function isValidEngine()
|
||||
{
|
||||
return extension_loaded('gmp');
|
||||
}
|
||||
|
||||
/**
|
||||
* Default constructor
|
||||
*
|
||||
* @param $x base-10 number or base-$base number if $base set.
|
||||
* @param int $base
|
||||
* @see parent::__construct()
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function __construct($x = 0, $base = 10)
|
||||
{
|
||||
if (!isset(self::$isValidEngine)) {
|
||||
self::$isValidEngine = self::isValidEngine();
|
||||
}
|
||||
if (!self::$isValidEngine) {
|
||||
throw new BadConfigurationException('GMP is not setup correctly on this system');
|
||||
}
|
||||
|
||||
if ($x instanceof \GMP) {
|
||||
$this->value = $x;
|
||||
return;
|
||||
}
|
||||
|
||||
$this->value = gmp_init(0);
|
||||
|
||||
parent::__construct($x, $base);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize a GMP BigInteger Engine instance
|
||||
*
|
||||
* @param int $base
|
||||
* @see parent::__construct()
|
||||
*/
|
||||
protected function initialize($base)
|
||||
{
|
||||
switch (abs($base)) {
|
||||
case 256:
|
||||
$sign = $this->is_negative ? '-' : '';
|
||||
$this->value = gmp_init($sign . '0x' . Hex::encode($this->value));
|
||||
break;
|
||||
case 16:
|
||||
$temp = $this->is_negative ? '-0x' . $this->value : '0x' . $this->value;
|
||||
$this->value = gmp_init($temp);
|
||||
break;
|
||||
case 10:
|
||||
$this->value = gmp_init(isset($this->value) ? $this->value : '0');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a BigInteger to a base-10 number.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function toString()
|
||||
{
|
||||
return (string) $this->value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a BigInteger to a byte string (eg. base-256).
|
||||
*
|
||||
* @param bool $twos_compliment
|
||||
* @return string
|
||||
*/
|
||||
function toBytes($twos_compliment = false)
|
||||
{
|
||||
if ($twos_compliment) {
|
||||
return $this->toBytesHelper();
|
||||
}
|
||||
|
||||
if (gmp_cmp($this->value, gmp_init(0)) == 0) {
|
||||
return $this->precision > 0 ? str_repeat(chr(0), ($this->precision + 1) >> 3) : '';
|
||||
}
|
||||
|
||||
$temp = gmp_strval(gmp_abs($this->value), 16);
|
||||
$temp = (strlen($temp) & 1) ? '0' . $temp : $temp;
|
||||
$temp = Hex::decode($temp);
|
||||
|
||||
return $this->precision > 0 ?
|
||||
substr(str_pad($temp, $this->precision >> 3, chr(0), STR_PAD_LEFT), -($this->precision >> 3)) :
|
||||
ltrim($temp, chr(0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function add(GMP $y)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = $this->value + $y->value;
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function subtract(GMP $y)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = $this->value - $y->value;
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Multiplies two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function multiply(GMP $x)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = $this->value * $x->value;
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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).
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function divide(GMP $y)
|
||||
{
|
||||
$quotient = new self();
|
||||
$remainder = new self();
|
||||
|
||||
list($quotient->value, $remainder->value) = gmp_div_qr($this->value, $y->value);
|
||||
|
||||
if (gmp_sign($remainder->value) < 0) {
|
||||
$remainder->value = $remainder->value + gmp_abs($y->value);
|
||||
}
|
||||
|
||||
return [$this->normalize($quotient), $this->normalize($remainder)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares two numbers.
|
||||
*
|
||||
* Although one might think !$x->compare($y) means $x != $y, it, in fact, means the opposite. The reason for this is
|
||||
* demonstrated thusly:
|
||||
*
|
||||
* $x > $y: $x->compare($y) > 0
|
||||
* $x < $y: $x->compare($y) < 0
|
||||
* $x == $y: $x->compare($y) == 0
|
||||
*
|
||||
* Note how the same comparison operator is used. If you want to test for equality, use $x->equals($y).
|
||||
*
|
||||
* @return int < 0 if $this is less than $y; > 0 if $this is greater than $y, and 0 if they are equal.
|
||||
* @access public
|
||||
* @see self::equals()
|
||||
* @internal Could return $this->subtract($x), but that's not as fast as what we do do.
|
||||
*/
|
||||
public function compare(GMP $y)
|
||||
{
|
||||
return gmp_cmp($this->value, $y->value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the equality of two numbers.
|
||||
*
|
||||
* If you need to see if one number is greater than or less than another number, use BigInteger::compare()
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function equals(GMP $x)
|
||||
{
|
||||
return $this->value == $x->value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates modular inverses.
|
||||
*
|
||||
* Say you have (30 mod 17 * x mod 17) mod 17 == 1. x can be found using modular inverses.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP|false
|
||||
*/
|
||||
public function modInverse(GMP $n)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = gmp_invert($this->value, $n->value);
|
||||
|
||||
return $temp->value === false ? false : $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the greatest common divisor and Bezout's identity.
|
||||
*
|
||||
* Say you have 693 and 609. The GCD is 21. Bezout's identity states that there exist integers x and y such that
|
||||
* 693*x + 609*y == 21. In point of fact, there are actually an infinite number of x and y combinations and which
|
||||
* combination is returned is dependent upon which mode is in use. See
|
||||
* {@link http://en.wikipedia.org/wiki/B%C3%A9zout%27s_identity Bezout's identity - Wikipedia} for more information.
|
||||
*
|
||||
* @param \phpseclib\Math\BigInteger\Engines\GMP $n
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function extendedGCD(GMP $n)
|
||||
{
|
||||
extract(gmp_gcdext($this->value, $n->value));
|
||||
|
||||
return [
|
||||
'gcd' => $this->normalize(new self($g)),
|
||||
'x' => $this->normalize(new self($s)),
|
||||
'y' => $this->normalize(new self($t))
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the greatest common divisor
|
||||
*
|
||||
* Say you have 693 and 609. The GCD is 21.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function gcd(GMP $n)
|
||||
{
|
||||
$r = gmp_gcd($this->value, $n->value);
|
||||
return $this->normalize(new self($r));
|
||||
}
|
||||
|
||||
/**
|
||||
* Absolute value.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
* @access public
|
||||
*/
|
||||
public function abs()
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = gmp_abs($this->value);
|
||||
|
||||
return $temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical And
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function bitwise_and(GMP $x)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = $this->value & $x->value;
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Or
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function bitwise_or(GMP $x)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = $this->value | $x->value;
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Exclusive Or
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function bitwise_xor(GMP $x)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = $this->value ^ $x->value;
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Right Shift
|
||||
*
|
||||
* Shifts BigInteger's by $shift bits, effectively dividing by 2**$shift.
|
||||
*
|
||||
* @param int $shift
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function bitwise_rightShift($shift)
|
||||
{
|
||||
// 0xFFFFFFFF >> 2 == -1 (on 32-bit systems)
|
||||
// gmp_init('0xFFFFFFFF') >> 2 == gmp_init('0x3FFFFFFF')
|
||||
|
||||
$temp = new self();
|
||||
$temp->value = $this->value >> $shift;
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Left Shift
|
||||
*
|
||||
* Shifts BigInteger's by $shift bits, effectively multiplying by 2**$shift.
|
||||
*
|
||||
* @param int $shift
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function bitwise_leftShift($shift)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = $this->value << $shift;
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function modPow(GMP $e, GMP $n)
|
||||
{
|
||||
return $this->powModOuter($e, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* Alias for modPow().
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function powMod(GMP $e, GMP $n)
|
||||
{
|
||||
return $this->powModOuter($e, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
protected function powModInner(GMP $e, GMP $n)
|
||||
{
|
||||
$class = self::$modexpEngine;
|
||||
return $class::powModHelper($this, $e, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalize
|
||||
*
|
||||
* Removes leading zeros and truncates (if necessary) to maintain the appropriate precision
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
protected function normalize(GMP $result)
|
||||
{
|
||||
$result->precision = $this->precision;
|
||||
$result->bitmask = $this->bitmask;
|
||||
|
||||
if ($result->bitmask !== false) {
|
||||
$result->value = $result->value & $result->bitmask->value;
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs some post-processing for randomRangePrime
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
protected static function randomRangePrimeInner(Engine $x, Engine $min, Engine $max)
|
||||
{
|
||||
$p = gmp_nextprime($x->value);
|
||||
|
||||
if ($p <= $max->value) {
|
||||
return new self($p);
|
||||
}
|
||||
|
||||
if ($min->value != $x->value) {
|
||||
$x = new self($x - 1);
|
||||
}
|
||||
|
||||
return self::randomRangePrime($min, $x);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random prime number between a range
|
||||
*
|
||||
* If there's not a prime within the given range, false will be returned.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP|false
|
||||
*/
|
||||
public static function randomRangePrime(GMP $min, GMP $max)
|
||||
{
|
||||
return self::randomRangePrimeOuter($min, $max);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random number between a range
|
||||
*
|
||||
* Returns a random number between $min and $max where $min and $max
|
||||
* can be defined using one of the two methods:
|
||||
*
|
||||
* BigInteger::randomRange($min, $max)
|
||||
* BigInteger::randomRange($max, $min)
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\Engine\GMP
|
||||
*/
|
||||
public static function randomRange(GMP $min, GMP $max)
|
||||
{
|
||||
return self::randomRangeHelper($min, $max);
|
||||
}
|
||||
|
||||
/**
|
||||
* Make the current number odd
|
||||
*
|
||||
* If the current number is odd it'll be unchanged. If it's even, one will be added to it.
|
||||
*
|
||||
* @see self::randomPrime()
|
||||
*/
|
||||
protected function make_odd()
|
||||
{
|
||||
gmp_setbit($this->value, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests Primality
|
||||
*
|
||||
* @param int $t
|
||||
* @return bool
|
||||
*/
|
||||
protected function testPrimality($t)
|
||||
{
|
||||
return gmp_prob_prime($this->value, $t) != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the nth root of a biginteger.
|
||||
*
|
||||
* Returns the nth root of a positive biginteger, where n defaults to 2
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\Engine\GMP
|
||||
*/
|
||||
protected function rootInner($n)
|
||||
{
|
||||
$root = new self();
|
||||
$root->value = gmp_root($this->value, $n);
|
||||
return $this->normalize($root);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public function pow(GMP $n)
|
||||
{
|
||||
$temp = new self();
|
||||
$temp->value = $this->value ** $n->value;
|
||||
|
||||
return $this->normalize($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the minimum BigInteger between an arbitrary number of BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public static function min(GMP ...$nums)
|
||||
{
|
||||
return self::minHelper($nums);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the maximum BigInteger between an arbitrary number of BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
public static function max(GMP ...$nums)
|
||||
{
|
||||
return self::maxHelper($nums);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests BigInteger to see if it is between two integers, inclusive
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function between(GMP $min, GMP $max)
|
||||
{
|
||||
return $this->compare($min) >= 0 && $this->compare($max) <= 0;
|
||||
}
|
||||
}
|
||||
41
phpseclib/Math/BigInteger/Engines/GMP/DefaultEngine.php
Normal file
41
phpseclib/Math/BigInteger/Engines/GMP/DefaultEngine.php
Normal file
@ -0,0 +1,41 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* GMP Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\GMP;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\GMP;
|
||||
|
||||
/**
|
||||
* GMP Modular Exponentiation Engine
|
||||
*
|
||||
* @package GMP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class DefaultEngine extends GMP
|
||||
{
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\GMP
|
||||
*/
|
||||
protected static function powModHelper(GMP $x, GMP $e, GMP $n)
|
||||
{
|
||||
$temp = new GMP();
|
||||
$temp->value = gmp_powm($x->value, $e->value, $n->value);
|
||||
|
||||
return $x->normalize($temp);
|
||||
}
|
||||
}
|
||||
71
phpseclib/Math/BigInteger/Engines/OpenSSL.php
Normal file
71
phpseclib/Math/BigInteger/Engines/OpenSSL.php
Normal file
@ -0,0 +1,71 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* OpenSSL Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines;
|
||||
|
||||
use phpseclib\Crypt\RSA;
|
||||
use phpseclib\Math\BigInteger;
|
||||
|
||||
/**
|
||||
* OpenSSL Modular Exponentiation Engine
|
||||
*
|
||||
* @package Engines
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class OpenSSL
|
||||
{
|
||||
/**
|
||||
* Test for engine validity
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public static function isValidEngine()
|
||||
{
|
||||
return extension_loaded('openssl') && static::class != __CLASS__;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\Engine
|
||||
*/
|
||||
public static function powModHelper(Engine $x, Engine $e, Engine $n)
|
||||
{
|
||||
if ($n->getLengthInBytes() < 31 || $n->getLengthInBytes() > 16384) {
|
||||
throw new \OutOfRangeException('Only modulo between 31 and 16384 bits are accepted');
|
||||
}
|
||||
|
||||
$rsa = new RSA();
|
||||
$rsa->load([
|
||||
'e' => new BigInteger($e),
|
||||
'n' => new BigInteger($n)
|
||||
]);
|
||||
//$rsa->setPublicKeyFormat('PKCS1');
|
||||
|
||||
$plaintext = str_pad($x->toBytes(), strlen($n->toBytes(true)) - 1, "\0", STR_PAD_LEFT);
|
||||
|
||||
// this is easily prone to failure. if the modulo is a multiple of 2 or 3 or whatever it
|
||||
// won't work and you'll get a "failure: error:0906D06C:PEM routines:PEM_read_bio:no start line"
|
||||
// error. i suppose, for even numbers, we could do what PHP\Montgomery.php does, but then what
|
||||
// about odd numbers divisible by 3, by 5, etc?
|
||||
if (!openssl_public_encrypt($plaintext, $result, "$rsa", OPENSSL_NO_PADDING)) {
|
||||
throw new \UnexpectedValueException(openssl_error_string());
|
||||
}
|
||||
|
||||
$class = get_class($x);
|
||||
return new $class($result, 256);
|
||||
}
|
||||
}
|
||||
1329
phpseclib/Math/BigInteger/Engines/PHP.php
Normal file
1329
phpseclib/Math/BigInteger/Engines/PHP.php
Normal file
File diff suppressed because it is too large
Load Diff
149
phpseclib/Math/BigInteger/Engines/PHP/Base.php
Normal file
149
phpseclib/Math/BigInteger/Engines/PHP/Base.php
Normal file
@ -0,0 +1,149 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHP Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\PHP;
|
||||
|
||||
/**
|
||||
* PHP Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Base extends PHP
|
||||
{
|
||||
/**#@+
|
||||
* @access private
|
||||
*/
|
||||
/**
|
||||
* Cache constants
|
||||
*
|
||||
* $cache[self::VARIABLE] tells us whether or not the cached data is still valid.
|
||||
*/
|
||||
const VARIABLE = 0;
|
||||
/**
|
||||
* $cache[self::DATA] contains the cached data.
|
||||
*/
|
||||
const DATA = 1;
|
||||
/**#@-*/
|
||||
|
||||
/**
|
||||
* Test for engine validity
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public static function isValidEngine()
|
||||
{
|
||||
return static::class != __CLASS__;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* @param \phpseclib\Math\BigInteger\Engines\PHP $x
|
||||
* @param \phpseclib\Math\BigInteger\Engines\PHP $e
|
||||
* @param \phpseclib\Math\BigInteger\Engines\PHP $n
|
||||
* @param string $class
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP
|
||||
*/
|
||||
protected static function powModHelper(PHP $x, PHP $e, PHP $n, $class)
|
||||
{
|
||||
if (empty($e->value)) {
|
||||
$temp = new $class();
|
||||
$temp->value = [1];
|
||||
return $x->normalize($temp);
|
||||
}
|
||||
|
||||
if ($e->value == [1]) {
|
||||
list(, $temp) = $x->divide($n);
|
||||
return $x->normalize($temp);
|
||||
}
|
||||
|
||||
if ($e->value == [2]) {
|
||||
$temp = new $class;
|
||||
$temp->value = $class::square($x->value);
|
||||
list(, $temp) = $temp->divide($n);
|
||||
return $x->normalize($temp);
|
||||
}
|
||||
|
||||
return $x->normalize(static::slidingWindow($x, $e, $n, $class));
|
||||
}
|
||||
|
||||
/**
|
||||
* Modular reduction preperation
|
||||
*
|
||||
* @param array $x
|
||||
* @param array $n
|
||||
* @param string $class
|
||||
* @see self::slidingWindow()
|
||||
* @return array
|
||||
*/
|
||||
protected static function prepareReduce(array $x, array $n, $class)
|
||||
{
|
||||
return static::reduce($x, $n, $class);
|
||||
}
|
||||
|
||||
/**
|
||||
* Modular multiply
|
||||
*
|
||||
* @param array $x
|
||||
* @param array $y
|
||||
* @param array $n
|
||||
* @param string $class
|
||||
* @see self::slidingWindow()
|
||||
* @return array
|
||||
*/
|
||||
protected static function multiplyReduce(array $x, array $y, array $n, $class)
|
||||
{
|
||||
$temp = $class::multiplyHelper($x, false, $y, false);
|
||||
return static::reduce($temp[self::VALUE], $n, $class);
|
||||
}
|
||||
|
||||
/**
|
||||
* Modular square
|
||||
*
|
||||
* @param array $x
|
||||
* @param array $n
|
||||
* @param string $class
|
||||
* @see self::slidingWindow()
|
||||
* @return array
|
||||
*/
|
||||
protected static function squareReduce(array $x, array $n, $class)
|
||||
{
|
||||
return static::reduce($class::square($x), $n, $class);
|
||||
}
|
||||
}
|
||||
29
phpseclib/Math/BigInteger/Engines/PHP/DefaultEngine.php
Normal file
29
phpseclib/Math/BigInteger/Engines/PHP/DefaultEngine.php
Normal file
@ -0,0 +1,29 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHP Default Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\PHP\Reductions\EvalBarrett;
|
||||
|
||||
/**
|
||||
* PHP Default Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class DefaultEngine extends EvalBarrett
|
||||
{
|
||||
}
|
||||
93
phpseclib/Math/BigInteger/Engines/PHP/Montgomery.php
Normal file
93
phpseclib/Math/BigInteger/Engines/PHP/Montgomery.php
Normal file
@ -0,0 +1,93 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHP Montgomery Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\PHP\Reductions\PowerOfTwo;
|
||||
use phpseclib\Math\BigInteger\Engines\PHP;
|
||||
use phpseclib\Math\BigInteger\Engines\PHP\Base;
|
||||
use phpseclib\Math\BigInteger\Engines\Engine;
|
||||
|
||||
/**
|
||||
* PHP Montgomery Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Montgomery extends Base
|
||||
{
|
||||
/**
|
||||
* Test for engine validity
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public static function isValidEngine()
|
||||
{
|
||||
return static::class != __CLASS__;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @param \phpseclib\Math\BigInteger\Engine $x
|
||||
* @param \phpseclib\Math\BigInteger\Engine $e
|
||||
* @param \phpseclib\Math\BigInteger\Engine $n
|
||||
* @param string $class
|
||||
* @return \phpseclib\Math\BigInteger\Engine
|
||||
*/
|
||||
protected static function slidingWindow(Engine $x, Engine $e, Engine $n, $class)
|
||||
{
|
||||
// is the modulo odd?
|
||||
if ($n->value[0] & 1) {
|
||||
return parent::slidingWindow($x, $e, $n, $class);
|
||||
}
|
||||
// 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+= $class::BASE * $i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// at this point, 2^$j * $n/(2^$j) == $n
|
||||
|
||||
$mod1 = clone $n;
|
||||
$mod1->rshift($j);
|
||||
$mod2 = new $class();
|
||||
$mod2->value = [1];
|
||||
$mod2->lshift($j);
|
||||
|
||||
$part1 = $mod1->value != [1] ? parent::slidingWindow($x, $e, $mod1, $class) : new $class();
|
||||
$part2 = PowerOfTwo::slidingWindow($x, $e, $mod2, $class);
|
||||
|
||||
$y1 = $mod2->modInverse($mod1);
|
||||
$y2 = $mod1->modInverse($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;
|
||||
}
|
||||
}
|
||||
29
phpseclib/Math/BigInteger/Engines/PHP/OpenSSL.php
Normal file
29
phpseclib/Math/BigInteger/Engines/PHP/OpenSSL.php
Normal file
@ -0,0 +1,29 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* OpenSSL Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\OpenSSL as Progenitor;
|
||||
|
||||
/**
|
||||
* OpenSSL Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class OpenSSL extends Progenitor
|
||||
{
|
||||
}
|
||||
284
phpseclib/Math/BigInteger/Engines/PHP/Reductions/Barrett.php
Normal file
284
phpseclib/Math/BigInteger/Engines/PHP/Reductions/Barrett.php
Normal file
@ -0,0 +1,284 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHP Barrett Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP\Reductions;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\PHP\Base;
|
||||
|
||||
/**
|
||||
* PHP Barrett Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Barrett extends Base
|
||||
{
|
||||
/**
|
||||
* 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).
|
||||
*
|
||||
* Employs "folding", as described at
|
||||
* {@link http://www.cosic.esat.kuleuven.be/publications/thesis-149.pdf#page=66 thesis-149.pdf#page=66}. To quote from
|
||||
* it, "the idea [behind folding] is to find a value x' such that x (mod m) = x' (mod m), with x' being smaller than x."
|
||||
*
|
||||
* Unfortunately, the "Barrett Reduction with Folding" algorithm described in thesis-149.pdf is not, as written, all that
|
||||
* usable on account of (1) its not using reasonable radix points as discussed in
|
||||
* {@link http://math.libtomcrypt.com/files/tommath.pdf#page=162 MPM 6.2.2} and (2) the fact that, even with reasonable
|
||||
* radix points, it only works when there are an even number of digits in the denominator. The reason for (2) is that
|
||||
* (x >> 1) + (x >> 1) != x / 2 + x / 2. If x is even, they're the same, but if x is odd, they're not. See the in-line
|
||||
* comments for details.
|
||||
*
|
||||
* @param array $n
|
||||
* @param array $m
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
protected static function reduce(array $n, array $m, $class)
|
||||
{
|
||||
static $cache = [
|
||||
self::VARIABLE => [],
|
||||
self::DATA => []
|
||||
];
|
||||
|
||||
$m_length = count($m);
|
||||
|
||||
// if (self::compareHelper($n, $static::square($m)) >= 0) {
|
||||
if (count($n) > 2 * $m_length) {
|
||||
$lhs = new $class();
|
||||
$rhs = new $class();
|
||||
$lhs->value = $n;
|
||||
$rhs->value = $m;
|
||||
list(, $temp) = $lhs->divide($rhs);
|
||||
return $temp->value;
|
||||
}
|
||||
|
||||
// if (m.length >> 1) + 2 <= m.length then m is too small and n can't be reduced
|
||||
if ($m_length < 5) {
|
||||
return self::regularBarrett($n, $m, $class);
|
||||
}
|
||||
// n = 2 * m.length
|
||||
|
||||
if (($key = array_search($m, $cache[self::VARIABLE])) === false) {
|
||||
$key = count($cache[self::VARIABLE]);
|
||||
$cache[self::VARIABLE][] = $m;
|
||||
|
||||
$lhs = new $class();
|
||||
$lhs_value = &$lhs->value;
|
||||
$lhs_value = self::array_repeat(0, $m_length + ($m_length >> 1));
|
||||
$lhs_value[] = 1;
|
||||
$rhs = new $class();
|
||||
$rhs->value = $m;
|
||||
|
||||
list($u, $m1) = $lhs->divide($rhs);
|
||||
$u = $u->value;
|
||||
$m1 = $m1->value;
|
||||
|
||||
$cache[self::DATA][] = [
|
||||
'u' => $u, // m.length >> 1 (technically (m.length >> 1) + 1)
|
||||
'm1'=> $m1 // m.length
|
||||
];
|
||||
} else {
|
||||
extract($cache[self::DATA][$key]);
|
||||
}
|
||||
|
||||
$cutoff = $m_length + ($m_length >> 1);
|
||||
$lsd = array_slice($n, 0, $cutoff); // m.length + (m.length >> 1)
|
||||
$msd = array_slice($n, $cutoff); // m.length >> 1
|
||||
|
||||
$lsd = self::trim($lsd);
|
||||
$temp = $class::multiplyHelper($msd, false, $m1, false); // m.length + (m.length >> 1)
|
||||
$n = $class::addHelper($lsd, false, $temp[self::VALUE], false); // m.length + (m.length >> 1) + 1 (so basically we're adding two same length numbers)
|
||||
//if ($m_length & 1) {
|
||||
// return self::regularBarrett($n[self::VALUE], $m, $class);
|
||||
//}
|
||||
|
||||
// (m.length + (m.length >> 1) + 1) - (m.length - 1) == (m.length >> 1) + 2
|
||||
$temp = array_slice($n[self::VALUE], $m_length - 1);
|
||||
// if even: ((m.length >> 1) + 2) + (m.length >> 1) == m.length + 2
|
||||
// if odd: ((m.length >> 1) + 2) + (m.length >> 1) == (m.length - 1) + 2 == m.length + 1
|
||||
$temp = $class::multiplyHelper($temp, false, $u, false);
|
||||
// if even: (m.length + 2) - ((m.length >> 1) + 1) = m.length - (m.length >> 1) + 1
|
||||
// if odd: (m.length + 1) - ((m.length >> 1) + 1) = m.length - (m.length >> 1)
|
||||
$temp = array_slice($temp[self::VALUE], ($m_length >> 1) + 1);
|
||||
// if even: (m.length - (m.length >> 1) + 1) + m.length = 2 * m.length - (m.length >> 1) + 1
|
||||
// if odd: (m.length - (m.length >> 1)) + m.length = 2 * m.length - (m.length >> 1)
|
||||
$temp = $class::multiplyHelper($temp, false, $m, false);
|
||||
|
||||
// at this point, if m had an odd number of digits, we'd be subtracting a 2 * m.length - (m.length >> 1) digit
|
||||
// number from a m.length + (m.length >> 1) + 1 digit number. ie. there'd be an extra digit and the while loop
|
||||
// following this comment would loop a lot (hence our calling _regularBarrett() in that situation).
|
||||
|
||||
$result = $class::subtractHelper($n[self::VALUE], false, $temp[self::VALUE], false);
|
||||
|
||||
while (self::compareHelper($result[self::VALUE], $result[self::SIGN], $m, false) >= 0) {
|
||||
$result = $class::subtractHelper($result[self::VALUE], $result[self::SIGN], $m, false);
|
||||
}
|
||||
|
||||
return $result[self::VALUE];
|
||||
}
|
||||
|
||||
/**
|
||||
* (Regular) Barrett Modular Reduction
|
||||
*
|
||||
* For numbers with more than four digits BigInteger::_barrett() is faster. The difference between that and this
|
||||
* is that this function does not fold the denominator into a smaller form.
|
||||
*
|
||||
* @param array $x
|
||||
* @param array $n
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
private static function regularBarrett(array $x, array $n, $class)
|
||||
{
|
||||
static $cache = [
|
||||
self::VARIABLE => [],
|
||||
self::DATA => []
|
||||
];
|
||||
|
||||
$n_length = count($n);
|
||||
|
||||
if (count($x) > 2 * $n_length) {
|
||||
$lhs = new $class();
|
||||
$rhs = new $class();
|
||||
$lhs->value = $x;
|
||||
$rhs->value = $n;
|
||||
list(, $temp) = $lhs->divide($rhs);
|
||||
return $temp->value;
|
||||
}
|
||||
|
||||
if (($key = array_search($n, $cache[self::VARIABLE])) === false) {
|
||||
$key = count($cache[self::VARIABLE]);
|
||||
$cache[self::VARIABLE][] = $n;
|
||||
$lhs = new $class();
|
||||
$lhs_value = &$lhs->value;
|
||||
$lhs_value = self::array_repeat(0, 2 * $n_length);
|
||||
$lhs_value[] = 1;
|
||||
$rhs = new $class();
|
||||
$rhs->value = $n;
|
||||
list($temp, ) = $lhs->divide($rhs); // m.length
|
||||
$cache[self::DATA][] = $temp->value;
|
||||
}
|
||||
|
||||
// 2 * m.length - (m.length - 1) = m.length + 1
|
||||
$temp = array_slice($x, $n_length - 1);
|
||||
// (m.length + 1) + m.length = 2 * m.length + 1
|
||||
$temp = $class::multiplyHelper($temp, false, $cache[self::DATA][$key], false);
|
||||
// (2 * m.length + 1) - (m.length - 1) = m.length + 2
|
||||
$temp = array_slice($temp[self::VALUE], $n_length + 1);
|
||||
|
||||
// m.length + 1
|
||||
$result = array_slice($x, 0, $n_length + 1);
|
||||
// m.length + 1
|
||||
$temp = self::multiplyLower($temp, false, $n, false, $n_length + 1);
|
||||
// $temp == array_slice($class::regularMultiply($temp, false, $n, false)->value, 0, $n_length + 1)
|
||||
|
||||
if (self::compareHelper($result, false, $temp[self::VALUE], $temp[self::SIGN]) < 0) {
|
||||
$corrector_value = self::array_repeat(0, $n_length + 1);
|
||||
$corrector_value[count($corrector_value)] = 1;
|
||||
$result = $class::addHelper($result, false, $corrector_value, false);
|
||||
$result = $result[self::VALUE];
|
||||
}
|
||||
|
||||
// at this point, we're subtracting a number with m.length + 1 digits from another number with m.length + 1 digits
|
||||
$result = $class::subtractHelper($result, false, $temp[self::VALUE], $temp[self::SIGN]);
|
||||
while (self::compareHelper($result[self::VALUE], $result[self::SIGN], $n, false) > 0) {
|
||||
$result = $class::subtractHelper($result[self::VALUE], $result[self::SIGN], $n, false);
|
||||
}
|
||||
|
||||
return $result[self::VALUE];
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs long multiplication up to $stop digits
|
||||
*
|
||||
* If you're going to be doing array_slice($product->value, 0, $stop), some cycles can be saved.
|
||||
*
|
||||
* @see self::regularBarrett()
|
||||
* @param array $x_value
|
||||
* @param bool $x_negative
|
||||
* @param array $y_value
|
||||
* @param bool $y_negative
|
||||
* @param int $stop
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
private static function multiplyLower(array $x_value, $x_negative, array $y_value, $y_negative, $stop, $class)
|
||||
{
|
||||
$x_length = count($x_value);
|
||||
$y_length = count($y_value);
|
||||
|
||||
if (!$x_length || !$y_length) { // a 0 is being multiplied
|
||||
return [
|
||||
self::VALUE => [],
|
||||
self::SIGN => false
|
||||
];
|
||||
}
|
||||
|
||||
if ($x_length < $y_length) {
|
||||
$temp = $x_value;
|
||||
$x_value = $y_value;
|
||||
$y_value = $temp;
|
||||
|
||||
$x_length = count($x_value);
|
||||
$y_length = count($y_value);
|
||||
}
|
||||
|
||||
$product_value = self::array_repeat(0, $x_length + $y_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;
|
||||
|
||||
for ($j = 0; $j < $x_length; ++$j) { // ie. $i = 0, $k = $i
|
||||
$temp = $x_value[$j] * $y_value[0] + $carry; // $product_value[$k] == 0
|
||||
$carry = $class::BASE === 26 ? intval($temp / 0x4000000) : ($temp >> 31);
|
||||
$product_value[$j] = (int) ($temp - $class::BASE_FULL * $carry);
|
||||
}
|
||||
|
||||
if ($j < $stop) {
|
||||
$product_value[$j] = $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 < $y_length; ++$i) {
|
||||
$carry = 0;
|
||||
|
||||
for ($j = 0, $k = $i; $j < $x_length && $k < $stop; ++$j, ++$k) {
|
||||
$temp = $product_value[$k] + $x_value[$j] * $y_value[$i] + $carry;
|
||||
$carry = $class::BASE === 26 ? intval($temp / 0x4000000) : ($temp >> 31);
|
||||
$product_value[$k] = (int) ($temp - $class::BASE_FULL * $carry);
|
||||
}
|
||||
|
||||
if ($k < $stop) {
|
||||
$product_value[$k] = $carry;
|
||||
}
|
||||
}
|
||||
|
||||
return [
|
||||
self::VALUE => self::trim($product_value),
|
||||
self::SIGN => $x_negative != $y_negative
|
||||
];
|
||||
}
|
||||
}
|
||||
46
phpseclib/Math/BigInteger/Engines/PHP/Reductions/Classic.php
Normal file
46
phpseclib/Math/BigInteger/Engines/PHP/Reductions/Classic.php
Normal file
@ -0,0 +1,46 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHP Classic Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP\Reductions;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\PHP\Base;
|
||||
|
||||
/**
|
||||
* PHP Classic Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Classic extends Base
|
||||
{
|
||||
/**
|
||||
* Regular Division
|
||||
*
|
||||
* @param array $x
|
||||
* @param array $n
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
protected static function reduce(array $x, array $n, $class)
|
||||
{
|
||||
$lhs = new $class();
|
||||
$lhs->value = $x;
|
||||
$rhs = new $class();
|
||||
$rhs->value = $n;
|
||||
list(, $temp) = $lhs->divide($rhs);
|
||||
return $temp->value;
|
||||
}
|
||||
}
|
||||
471
phpseclib/Math/BigInteger/Engines/PHP/Reductions/EvalBarrett.php
Normal file
471
phpseclib/Math/BigInteger/Engines/PHP/Reductions/EvalBarrett.php
Normal file
@ -0,0 +1,471 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHP Dynamic Barrett Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP\Reductions;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\PHP\Base;
|
||||
use phpseclib\Math\BigInteger\Engines\PHP;
|
||||
|
||||
/**
|
||||
* PHP Dynamic Barrett Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class EvalBarrett extends Base
|
||||
{
|
||||
/**
|
||||
* Custom Reduction Function
|
||||
*
|
||||
* @see self::generateCustomReduction
|
||||
*/
|
||||
private static $custom_reduction;
|
||||
|
||||
/**
|
||||
* Barrett Modular Reduction
|
||||
*
|
||||
* This calls a dynamically generated loop unrolled function that's specific to a given modulo.
|
||||
* Array lookups are avoided as are if statements testing for how many bits the host OS supports, etc.
|
||||
*
|
||||
* @param array $n
|
||||
* @param array $m
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
protected static function reduce(array $n, array $m, $class)
|
||||
{
|
||||
$inline = self::$custom_reduction;
|
||||
return $inline($n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate Custom Reduction
|
||||
*
|
||||
* @param PHP $m
|
||||
* @param string $class
|
||||
* @return callable
|
||||
*/
|
||||
protected static function generateCustomReduction(PHP $m, $class)
|
||||
{
|
||||
$m_length = count($m->value);
|
||||
|
||||
if ($m_length < 5) {
|
||||
$code = '
|
||||
$lhs = new ' . $class . '();
|
||||
$lhs->value = $x;
|
||||
$rhs = new ' . $class . '();
|
||||
$rhs->value = [' .
|
||||
implode(',', array_map('self::float2string', $m->value)) . '];
|
||||
list(, $temp) = $lhs->divide($rhs);
|
||||
return $temp->value;
|
||||
';
|
||||
eval('$func = function ($x) { ' . $code . '};');
|
||||
self::$custom_reduction = $func;
|
||||
//self::$custom_reduction = \Closure::bind($func, $m, $class);
|
||||
return;
|
||||
}
|
||||
|
||||
$lhs = new $class();
|
||||
$lhs_value = &$lhs->value;
|
||||
$lhs_value = self::array_repeat(0, $m_length + ($m_length >> 1));
|
||||
$lhs_value[] = 1;
|
||||
$rhs = new $class();
|
||||
|
||||
list($u, $m1) = $lhs->divide($m);
|
||||
|
||||
$m = $m->value;
|
||||
$u = $u->value;
|
||||
$m1 = $m1->value;
|
||||
|
||||
$cutoff = count($m) + (count($m) >> 1);
|
||||
|
||||
$code = '
|
||||
if (count($n) > ' . (2 * count($m)) . ') {
|
||||
$lhs = new ' . $class . '();
|
||||
$rhs = new ' . $class . '();
|
||||
$lhs->value = $n;
|
||||
$rhs->value = [' .
|
||||
implode(',', array_map('self::float2string', $m)) . '];
|
||||
list(, $temp) = $lhs->divide($rhs);
|
||||
return $temp->value;
|
||||
}
|
||||
|
||||
$lsd = array_slice($n, 0, ' . $cutoff . ');
|
||||
$msd = array_slice($n, ' . $cutoff . ');';
|
||||
|
||||
$code.= self::generateInlineTrim('msd');
|
||||
$code.= self::generateInlineMultiply('msd', $m1, 'temp', $class);
|
||||
$code.= self::generateInlineAdd('lsd', 'temp', 'n', $class);
|
||||
|
||||
$code.= '
|
||||
$temp = array_slice($n, ' . (count($m) - 1) . ');';
|
||||
$code.= self::generateInlineMultiply('temp', $u, 'temp2', $class);
|
||||
$code.= self::generateInlineTrim('temp2');
|
||||
$code.= '
|
||||
$temp = array_slice($temp2, ' . ((count($m) >> 1) + 1) . ');';
|
||||
$code.= self::generateInlineMultiply('temp', $m, 'temp2', $class);
|
||||
$code.= self::generateInlineTrim('temp2');
|
||||
|
||||
$code.= self::generateInlineSubtract2('n', 'temp2', 'temp', $class);
|
||||
|
||||
$subcode = self::generateInlineSubtract1('temp', $m, 'temp2', $class);
|
||||
$subcode.= '$temp = $temp2;';
|
||||
|
||||
$code.= self::generateInlineCompare($m, 'temp', $subcode);
|
||||
|
||||
$code.= 'return $temp;';
|
||||
|
||||
eval('$func = function ($n) { ' . $code . '};');
|
||||
|
||||
self::$custom_reduction = $func;
|
||||
|
||||
//self::$custom_reduction = \Closure::bind($func, $m, $class);
|
||||
}
|
||||
|
||||
/**
|
||||
* Inline Trim
|
||||
*
|
||||
* Removes leading zeros
|
||||
*
|
||||
* @param string $name
|
||||
* @return string
|
||||
*/
|
||||
private static function generateInlineTrim($name)
|
||||
{
|
||||
return '
|
||||
for ($i = count($' . $name . ') - 1; $i >= 0; --$i) {
|
||||
if ($' . $name . '[$i]) {
|
||||
break;
|
||||
}
|
||||
unset($' . $name . '[$i]);
|
||||
}';
|
||||
}
|
||||
|
||||
/**
|
||||
* Inline Multiply (unknown, known)
|
||||
*
|
||||
* @param string $input
|
||||
* @param array $arr
|
||||
* @param string $output
|
||||
* @param string $class
|
||||
* @return string
|
||||
*/
|
||||
private static function generateInlineMultiply($input, array $arr, $output, $class)
|
||||
{
|
||||
if (!count($arr)) {
|
||||
return 'return [];';
|
||||
}
|
||||
|
||||
$label = 'label_' . uniqid();
|
||||
|
||||
$regular = '
|
||||
$length = count($' . $input . ');
|
||||
if (!$length) {
|
||||
$' . $output . ' = [];
|
||||
goto ' . $label . ';
|
||||
}
|
||||
$' . $output . ' = array_fill(0, $length + ' . count($arr) . ', 0);
|
||||
$carry = 0;';
|
||||
|
||||
for ($i = 0; $i < count($arr); $i++) {
|
||||
$regular.= '
|
||||
$subtemp = $' . $input . '[0] * ' . $arr[$i];
|
||||
$regular.= $i ? ' + $carry;' : ';';
|
||||
|
||||
$regular.= '$carry = ';
|
||||
$regular.= $class::BASE === 26 ?
|
||||
'intval($subtemp / 0x4000000);' :
|
||||
'$subtemp >> 31;';
|
||||
$regular.=
|
||||
'$' . $output . '[' . $i . '] = ';
|
||||
if ($class::BASE === 26) {
|
||||
$regular.= '(int) (';
|
||||
}
|
||||
$regular.= '$subtemp - ' . $class::BASE_FULL . ' * $carry';
|
||||
$regular.= $class::BASE === 26 ? ');' : ';';
|
||||
}
|
||||
|
||||
$regular.= '$' . $output . '[' . count($arr) . '] = $carry;';
|
||||
|
||||
$regular.= '
|
||||
for ($i = 1; $i < $length; ++$i) {';
|
||||
|
||||
for ($j = 0; $j < count($arr); $j++) {
|
||||
$regular.= $j ? '$k++;' : '$k = $i;';
|
||||
$regular.= '
|
||||
$subtemp = $' . $output . '[$k] + $' . $input . '[$i] * ' . $arr[$j];
|
||||
$regular.= $j ? ' + $carry;' : ';';
|
||||
|
||||
$regular.= '$carry = ';
|
||||
$regular.= $class::BASE === 26 ?
|
||||
'intval($subtemp / 0x4000000);' :
|
||||
'$subtemp >> 31;';
|
||||
$regular.=
|
||||
'$' . $output . '[$k] = ';
|
||||
if ($class::BASE === 26) {
|
||||
$regular.= '(int) (';
|
||||
}
|
||||
$regular.= '$subtemp - ' . $class::BASE_FULL . ' * $carry';
|
||||
$regular.= $class::BASE === 26 ? ');' : ';';
|
||||
}
|
||||
|
||||
$regular.= '$' . $output. '[++$k] = $carry; $carry = 0;';
|
||||
|
||||
$regular.= '}';
|
||||
|
||||
$regular.= $label . ':';
|
||||
|
||||
//if (count($arr) < 2 * self::KARATSUBA_CUTOFF) {
|
||||
//}
|
||||
|
||||
return $regular;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inline Addition
|
||||
*
|
||||
* @param string $x
|
||||
* @param string $y
|
||||
* @param string $result
|
||||
* @param string $class
|
||||
* @return string
|
||||
*/
|
||||
private static function generateInlineAdd($x, $y, $result, $class)
|
||||
{
|
||||
$code = '
|
||||
$length = max(count($' . $x . '), count($' . $y . '));
|
||||
$' . $result . ' = array_pad($' . $x . ', $length, 0);
|
||||
$_' . $y . ' = array_pad($' . $y . ', $length, 0);
|
||||
$carry = 0;
|
||||
for ($i = 0, $j = 1; $j < $length; $i+=2, $j+=2) {
|
||||
$sum = $' . $result . '[$j] * ' . $class::BASE_FULL . ' + $' . $result . '[$i] +
|
||||
$_' . $y . '[$j] * ' . $class::BASE_FULL . ' + $_' . $y . '[$i] +
|
||||
$carry;
|
||||
$carry = $sum >= ' . self::float2string($class::MAX_DIGIT2) . ';
|
||||
$sum = $carry ? $sum - ' . self::float2string($class::MAX_DIGIT2) . ' : $sum;';
|
||||
|
||||
$code.= $class::BASE === 26 ?
|
||||
'$upper = intval($sum / 0x4000000); $' . $result . '[$i] = (int) ($sum - ' . $class::BASE_FULL . ' * $upper);' :
|
||||
'$upper = $sum >> 31; $' . $result . '[$i] = $sum - ' . $class::BASE_FULL . ' * $upper;';
|
||||
$code.= '
|
||||
$' . $result . '[$j] = $upper;
|
||||
}
|
||||
if ($j == $length) {
|
||||
$sum = $' . $result . '[$i] + $_' . $y . '[$i] + $carry;
|
||||
$carry = $sum >= ' . self::float2string($class::MAX_DIGIT2) . ';
|
||||
$' . $result . '[$i] = $carry ? $sum - ' . self::float2string($class::MAX_DIGIT2) . ' : $sum;
|
||||
}
|
||||
if ($carry) {
|
||||
$' . $result . '[] = $carry;
|
||||
}';
|
||||
$code.= self::generateInlineTrim($result);
|
||||
|
||||
return $code;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inline Subtraction 2
|
||||
*
|
||||
* For when $known is more digits than $unknown. This is the harder use case to optimize for.
|
||||
*
|
||||
* @param string $known
|
||||
* @param string $unknown
|
||||
* @param string $result
|
||||
* @param string $class
|
||||
* @return string
|
||||
*/
|
||||
private static function generateInlineSubtract2($known, $unknown, $result, $class)
|
||||
{
|
||||
$code = '
|
||||
$' . $result .' = $' . $known . ';
|
||||
$carry = 0;
|
||||
$size = count($' . $unknown . ');
|
||||
for ($i = 0, $j = 1; $j < $size; $i+= 2, $j+= 2) {
|
||||
$sum = $' . $known . '[$j] * ' . $class::BASE_FULL . ' + $' . $known . '[$i]
|
||||
- $' . $unknown . '[$j] * ' . $class::BASE_FULL . ' - $' . $unknown . '[$i]
|
||||
- $carry;
|
||||
$carry = $sum < 0;
|
||||
if ($carry) {
|
||||
$sum+= ' . self::float2string($class::MAX_DIGIT2) . ';
|
||||
}
|
||||
$subtemp = ';
|
||||
$code.= $class::BASE === 26 ?
|
||||
'intval($sum / 0x4000000);' :
|
||||
'$sum >> 31;';
|
||||
$code.= '$' . $result . '[$i] = ';
|
||||
if ($class::BASE === 26) {
|
||||
$code.= '(int) (';
|
||||
}
|
||||
$code.= '$sum - ' . $class::BASE_FULL . ' * $subtemp';
|
||||
if ($class::BASE === 26) {
|
||||
$code.= ')';
|
||||
}
|
||||
$code.= ';
|
||||
$' . $result . '[$j] = $subtemp;
|
||||
}
|
||||
if ($j == $size) {
|
||||
$sum = $' . $known . '[$i] - $' . $unknown . '[$i] - $carry;
|
||||
$carry = $sum < 0;
|
||||
$' . $result . '[$i] = $carry ? $sum + ' . $class::BASE_FULL . ' : $sum;
|
||||
++$i;
|
||||
}
|
||||
|
||||
if ($carry) {
|
||||
for (; !$' . $result . '; ++$i) {
|
||||
$' . $result . '[$i] = ' . $class::MAX_DIGIT . ';
|
||||
}
|
||||
--$' . $result . '[$i];
|
||||
}';
|
||||
|
||||
$code.= self::generateInlineTrim($result);
|
||||
|
||||
return $code;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inline Subtraction 1
|
||||
*
|
||||
* For when $unknown is more digits than $known. This is the easier use case to optimize for.
|
||||
*
|
||||
* @param string $unknown
|
||||
* @param array $known
|
||||
* @param string $result
|
||||
* @param string $class
|
||||
* @return string
|
||||
*/
|
||||
private static function generateInlineSubtract1($unknown, array $known, $result, $class)
|
||||
{
|
||||
$code = '$' . $result . ' = $' . $unknown . ';';
|
||||
for ($i = 0, $j = 1; $j < count($known); $i+=2, $j+=2) {
|
||||
$code.= '$sum = $' . $unknown . '[' . $j . '] * ' . $class::BASE_FULL . ' + $' . $unknown . '[' . $i . '] - ';
|
||||
$code.= self::float2string($known[$j] * $class::BASE_FULL + $known[$i]);
|
||||
if ($i != 0) {
|
||||
$code.= ' - $carry';
|
||||
}
|
||||
|
||||
$code.= ';
|
||||
if ($carry = $sum < 0) {
|
||||
$sum+= ' . self::float2string($class::MAX_DIGIT2) . ';
|
||||
}
|
||||
$subtemp = ';
|
||||
$code.= $class::BASE === 26 ?
|
||||
'intval($sum / 0x4000000);' :
|
||||
'$sum >> 31;';
|
||||
$code.= '
|
||||
$' . $result . '[' . $i . '] = ';
|
||||
if ($class::BASE === 26) {
|
||||
$code.= ' (int) (';
|
||||
}
|
||||
$code.= '$sum - ' . $class::BASE_FULL . ' * $subtemp';
|
||||
if ($class::BASE === 26) {
|
||||
$code.= ')';
|
||||
}
|
||||
$code.= ';
|
||||
$' . $result . '[' . $j . '] = $subtemp;';
|
||||
}
|
||||
|
||||
$code.= '$i = ' . $i . ';';
|
||||
|
||||
if ($j == count($known)) {
|
||||
$code.= '
|
||||
$sum = $' . $unknown . '[' . $i . '] - ' . $known[$i] . ' - $carry;
|
||||
$carry = $sum < 0;
|
||||
$' . $result . '[' . $i . '] = $carry ? $sum + ' . $class::BASE_FULL . ' : $sum;
|
||||
++$i;';
|
||||
}
|
||||
|
||||
$code.= '
|
||||
if ($carry) {
|
||||
for (; !$' . $result . '[$i]; ++$i) {
|
||||
$' . $result . '[$i] = ' . $class::MAX_DIGIT . ';
|
||||
}
|
||||
--$' . $result . '[$i];
|
||||
}';
|
||||
$code.= self::generateInlineTrim($result);
|
||||
|
||||
return $code;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inline Comparison
|
||||
*
|
||||
* If $uknown >= $known then loop
|
||||
*
|
||||
* @param array $known
|
||||
* @param string $unknown
|
||||
* @param string $subcode
|
||||
* @return string
|
||||
*/
|
||||
private static function generateInlineCompare(array $known, $unknown, $subcode)
|
||||
{
|
||||
$uniqid = uniqid();
|
||||
$code = 'loop_' . $uniqid . ':
|
||||
$clength = count($' . $unknown . ');
|
||||
switch (true) {
|
||||
case $clength < ' . count($known) . ':
|
||||
goto end_' . $uniqid . ';
|
||||
case $clength > ' . count($known) . ':';
|
||||
for ($i = count($known) - 1; $i >= 0; $i--) {
|
||||
$code.= '
|
||||
case $' . $unknown . '[' . $i . '] > ' . $known[$i] . ':
|
||||
goto subcode_' . $uniqid . ';
|
||||
case $' . $unknown . '[' . $i . '] < ' . $known[$i] . ':
|
||||
goto end_' . $uniqid . ';';
|
||||
}
|
||||
$code.= '
|
||||
default:
|
||||
// do subcode
|
||||
}
|
||||
|
||||
subcode_' . $uniqid . ':' . $subcode . '
|
||||
goto loop_' . $uniqid . ';
|
||||
|
||||
end_' . $uniqid . ':';
|
||||
|
||||
return $code;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a float to a string
|
||||
*
|
||||
* If you do echo floatval(pow(2, 52)) you'll get 4.6116860184274E+18. It /can/ be displayed without a loss of
|
||||
* precision but displayed in this way there will be precision loss, hence the need for this method.
|
||||
*
|
||||
* @param string $x
|
||||
* @param string $y
|
||||
* @param string $result
|
||||
* @param string $class
|
||||
* @return string
|
||||
*/
|
||||
private static function float2string($num)
|
||||
{
|
||||
if (!is_float($num)) {
|
||||
return $num;
|
||||
}
|
||||
|
||||
if ($num < 0) {
|
||||
return '-' . self::float2string(abs($num));
|
||||
}
|
||||
|
||||
$temp = '';
|
||||
while ($num) {
|
||||
$temp = fmod($num, 10) . $temp;
|
||||
$num = floor($num / 10);
|
||||
}
|
||||
|
||||
return $temp;
|
||||
}
|
||||
}
|
||||
130
phpseclib/Math/BigInteger/Engines/PHP/Reductions/Montgomery.php
Normal file
130
phpseclib/Math/BigInteger/Engines/PHP/Reductions/Montgomery.php
Normal file
@ -0,0 +1,130 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHP Montgomery Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP\Reductions;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\PHP\Montgomery as Progenitor;
|
||||
|
||||
/**
|
||||
* PHP Montgomery Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Montgomery extends Progenitor
|
||||
{
|
||||
/**
|
||||
* Prepare a number for use in Montgomery Modular Reductions
|
||||
*
|
||||
* @param array $x
|
||||
* @param array $n
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
protected static function prepareReduce(array $x, array $n, $class)
|
||||
{
|
||||
$lhs = new $class();
|
||||
$lhs->value = array_merge(self::array_repeat(0, count($n)), $x);
|
||||
$rhs = new $class();
|
||||
$rhs->value = $n;
|
||||
|
||||
list(, $temp) = $lhs->divide($rhs);
|
||||
return $temp->value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Montgomery Multiply
|
||||
*
|
||||
* Interleaves the montgomery reduction and long multiplication algorithms together as described in
|
||||
* {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=13 HAC 14.36}
|
||||
*
|
||||
* @param array $x
|
||||
* @param array $n
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
protected static function reduce(array $x, array $n, $class)
|
||||
{
|
||||
static $cache = [
|
||||
self::VARIABLE => [],
|
||||
self::DATA => []
|
||||
];
|
||||
|
||||
if (($key = array_search($n, $cache[self::VARIABLE])) === false) {
|
||||
$key = count($cache[self::VARIABLE]);
|
||||
$cache[self::VARIABLE][] = $x;
|
||||
$cache[self::DATA][] = self::modInverse67108864($n, $class);
|
||||
}
|
||||
|
||||
$k = count($n);
|
||||
|
||||
$result = [self::VALUE => $x];
|
||||
|
||||
for ($i = 0; $i < $k; ++$i) {
|
||||
$temp = $result[self::VALUE][$i] * $cache[self::DATA][$key];
|
||||
$temp = $temp - $class::BASE_FULL * ($class::BASE === 26 ? intval($temp / 0x4000000) : ($temp >> 31));
|
||||
$temp = $class::regularMultiply([$temp], $n);
|
||||
$temp = array_merge(self::array_repeat(0, $i), $temp);
|
||||
$result = $class::addHelper($result[self::VALUE], false, $temp, false);
|
||||
}
|
||||
|
||||
$result[self::VALUE] = array_slice($result[self::VALUE], $k);
|
||||
|
||||
if (self::compareHelper($result, false, $n, false) >= 0) {
|
||||
$result = $class::subtractHelper($result[self::VALUE], false, $n, false);
|
||||
}
|
||||
|
||||
return $result[self::VALUE];
|
||||
}
|
||||
|
||||
/**
|
||||
* 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!
|
||||
*
|
||||
* @param array $x
|
||||
* @param string $class
|
||||
* @return int
|
||||
*/
|
||||
protected static function modInverse67108864(array $x, $class) // 2**26 == 67,108,864
|
||||
{
|
||||
$x = -$x[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 = $class::BASE == 26 ?
|
||||
fmod($result * (2 - fmod($x * $result, $class::BASE_FULL)), $class::BASE_FULL) : // x**-1 mod 2**26
|
||||
($result * (2 - ($x * $result) % $class::BASE_FULL)) % $class::BASE_FULL;
|
||||
return $result & $class::MAX_DIGIT;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,81 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHP Montgomery Modular Exponentiation Engine with interleaved multiplication
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP\Reductions;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\PHP\Base;
|
||||
|
||||
/**
|
||||
* PHP Montgomery Modular Exponentiation Engine with interleaved multiplication
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class MontgomeryMult extends Montgomery
|
||||
{
|
||||
/**
|
||||
* Montgomery Multiply
|
||||
*
|
||||
* Interleaves the montgomery reduction and long multiplication algorithms together as described in
|
||||
* {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf#page=13 HAC 14.36}
|
||||
*
|
||||
* @see self::_prepMontgomery()
|
||||
* @see self::_montgomery()
|
||||
* @access private
|
||||
* @param array $x
|
||||
* @param array $y
|
||||
* @param array $m
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
public static function multiplyReduce(array $x, array $y, array $m, $class)
|
||||
{
|
||||
// the following code, although not callable, can be run independently of the above code
|
||||
// although the above code performed better in my benchmarks the following could might
|
||||
// perform better under different circumstances. in lieu of deleting it it's just been
|
||||
// made uncallable
|
||||
|
||||
static $cache = [
|
||||
self::VARIABLE => [],
|
||||
self::DATA => []
|
||||
];
|
||||
|
||||
if (($key = array_search($m, $cache[self::VARIABLE])) === false) {
|
||||
$key = count($cache[self::VARIABLE]);
|
||||
$cache[self::VARIABLE][] = $m;
|
||||
$cache[self::DATA][] = self::modInverse67108864($m, $class);
|
||||
}
|
||||
|
||||
$n = max(count($x), count($y), count($m));
|
||||
$x = array_pad($x, $n, 0);
|
||||
$y = array_pad($y, $n, 0);
|
||||
$m = array_pad($m, $n, 0);
|
||||
$a = [self::VALUE => self::array_repeat(0, $n + 1)];
|
||||
for ($i = 0; $i < $n; ++$i) {
|
||||
$temp = $a[self::VALUE][0] + $x[$i] * $y[0];
|
||||
$temp = $temp - $class::BASE_FULL * ($class::BASE === 26 ? intval($temp / 0x4000000) : ($temp >> 31));
|
||||
$temp = $temp * $cache[self::DATA][$key];
|
||||
$temp = $temp - $class::BASE_FULL * ($class::BASE === 26 ? intval($temp / 0x4000000) : ($temp >> 31));
|
||||
$temp = $class::addHelper($class::regularMultiply([$x[$i]], $y), false, $class::regularMultiply([$temp], $m), false);
|
||||
$a = $class::addHelper($a[self::VALUE], false, $temp[self::VALUE], false);
|
||||
$a[self::VALUE] = array_slice($a[self::VALUE], 1);
|
||||
}
|
||||
if (self::compareHelper($a[self::VALUE], false, $m, false) >= 0) {
|
||||
$a = $class::subtractHelper($a[self::VALUE], false, $m, false);
|
||||
}
|
||||
return $a[self::VALUE];
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,63 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHP Power of Two Modular Exponentiation Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines\PHP\Reductions;
|
||||
|
||||
use phpseclib\Math\BigInteger\Engines\PHP\Base;
|
||||
|
||||
/**
|
||||
* PHP Power Of Two Modular Exponentiation Engine
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class PowerOfTwo extends Base
|
||||
{
|
||||
/**
|
||||
* Prepare a number for use in Montgomery Modular Reductions
|
||||
*
|
||||
* @param array $x
|
||||
* @param array $n
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
protected static function prepareReduce(array $x, array $n, $class)
|
||||
{
|
||||
return self::reduce($x, $n, $class);
|
||||
}
|
||||
|
||||
/**
|
||||
* Power Of Two Reduction
|
||||
*
|
||||
* @param array $x
|
||||
* @param array $n
|
||||
* @param string $class
|
||||
* @return array
|
||||
*/
|
||||
protected static function reduce(array $x, array $n, $class)
|
||||
{
|
||||
$lhs = new $class();
|
||||
$lhs->value = $x;
|
||||
$rhs = new $class();
|
||||
$rhs->value = $n;
|
||||
|
||||
$temp = new $class();
|
||||
$temp->value = [1];
|
||||
|
||||
$result = $lhs->bitwise_and($rhs->subtract($temp));
|
||||
return $result->value;
|
||||
}
|
||||
}
|
||||
343
phpseclib/Math/BigInteger/Engines/PHP32.php
Normal file
343
phpseclib/Math/BigInteger/Engines/PHP32.php
Normal file
@ -0,0 +1,343 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Pure-PHP 32-bit BigInteger Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines;
|
||||
|
||||
use ParagonIE\ConstantTime\Hex;
|
||||
|
||||
/**
|
||||
* Pure-PHP 32-bit Engine.
|
||||
*
|
||||
* Uses 64-bit floats if int size is 4 bits
|
||||
*
|
||||
* @package PHP32
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
class PHP32 extends PHP
|
||||
{
|
||||
/**#@+
|
||||
* Constants used by PHP.php
|
||||
*/
|
||||
const BASE = 26;
|
||||
const BASE_FULL = 0x4000000;
|
||||
const MAX_DIGIT = 0x3FFFFFF;
|
||||
const MSB = 0x2000000;
|
||||
|
||||
/**
|
||||
* MAX10 in greatest MAX10LEN satisfying
|
||||
* MAX10 = 10**MAX10LEN <= 2**BASE.
|
||||
*/
|
||||
const MAX10 = 10000000;
|
||||
|
||||
/**
|
||||
* MAX10LEN in greatest MAX10LEN satisfying
|
||||
* MAX10 = 10**MAX10LEN <= 2**BASE.
|
||||
*/
|
||||
const MAX10LEN = 7;
|
||||
const MAX_DIGIT2 = 4503599627370496;
|
||||
/**#@-*/
|
||||
|
||||
/**
|
||||
* Modular Exponentiation Engine
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected static $modexpEngine;
|
||||
|
||||
/**
|
||||
* Engine Validity Flag
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
protected static $isValidEngine;
|
||||
|
||||
/**
|
||||
* Primes > 2 and < 1000
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $primes;
|
||||
|
||||
/**
|
||||
* BigInteger(0)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
protected static $zero;
|
||||
|
||||
/**
|
||||
* BigInteger(1)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
protected static $one;
|
||||
|
||||
/**
|
||||
* BigInteger(2)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
protected static $two;
|
||||
|
||||
/**
|
||||
* Test for engine validity
|
||||
*
|
||||
* @see parent::__construct()
|
||||
* @return bool
|
||||
*/
|
||||
public static function isValidEngine()
|
||||
{
|
||||
return PHP_INT_SIZE >= 4;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function add(PHP32 $y)
|
||||
{
|
||||
$temp = self::addHelper($this->value, $this->is_negative, $y->value, $y->is_negative);
|
||||
|
||||
return $this->convertToObj($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function subtract(PHP32 $y)
|
||||
{
|
||||
$temp = self::subtractHelper($this->value, $this->is_negative, $y->value, $y->is_negative);
|
||||
|
||||
return $this->convertToObj($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Multiplies two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function multiply(PHP32 $y)
|
||||
{
|
||||
$temp = self::multiplyHelper($this->value, $this->is_negative, $y->value, $y->is_negative);
|
||||
|
||||
return $this->convertToObj($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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).
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function divide(PHP32 $y)
|
||||
{
|
||||
return $this->divideHelper($y);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates modular inverses.
|
||||
*
|
||||
* Say you have (30 mod 17 * x mod 17) mod 17 == 1. x can be found using modular inverses.
|
||||
*/
|
||||
public function modInverse(PHP32 $n)
|
||||
{
|
||||
return $this->modInverseHelper($n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates modular inverses.
|
||||
*
|
||||
* Say you have (30 mod 17 * x mod 17) mod 17 == 1. x can be found using modular inverses.
|
||||
*/
|
||||
public function extendedGCD(PHP32 $n)
|
||||
{
|
||||
return $this->extendedGCDHelper($n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the greatest common divisor
|
||||
*
|
||||
* Say you have 693 and 609. The GCD is 21.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function gcd(PHP32 $n)
|
||||
{
|
||||
extract($this->extendedGCD($n));
|
||||
return $gcd;
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical And
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function bitwise_and(PHP32 $x)
|
||||
{
|
||||
return $this->bitwiseAndHelper($x);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Or
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function bitwise_or(PHP32 $x)
|
||||
{
|
||||
return $this->bitwiseOrHelper($x);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Exlusive Or
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function bitwise_xor(PHP32 $x)
|
||||
{
|
||||
return $this->bitwiseXorHelper($x);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares two numbers.
|
||||
*
|
||||
* Although one might think !$x->compare($y) means $x != $y, it, in fact, means the opposite. The reason for this is
|
||||
* demonstrated thusly:
|
||||
*
|
||||
* $x > $y: $x->compare($y) > 0
|
||||
* $x < $y: $x->compare($y) < 0
|
||||
* $x == $y: $x->compare($y) == 0
|
||||
*
|
||||
* Note how the same comparison operator is used. If you want to test for equality, use $x->equals($y).
|
||||
*
|
||||
* @return int < 0 if $this is less than $y; > 0 if $this is greater than $y, and 0 if they are equal.
|
||||
* @access public
|
||||
* @see self::equals()
|
||||
* @internal Could return $this->subtract($x), but that's not as fast as what we do do.
|
||||
*/
|
||||
public function compare(PHP32 $y)
|
||||
{
|
||||
return $this->compareHelper($this->value, $this->is_negative, $y->value, $y->is_negative);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the equality of two numbers.
|
||||
*
|
||||
* If you need to see if one number is greater than or less than another number, use BigInteger::compare()
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function equals(PHP32 $x)
|
||||
{
|
||||
return $this->value === $x->value && $this->is_negative == $x->is_negative;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function modPow(PHP32 $e, PHP32 $n)
|
||||
{
|
||||
return $this->powModOuter($e, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* Alias for modPow().
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public function powMod(PHP32 $e, PHP32 $n)
|
||||
{
|
||||
return $this->powModOuter($e, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random prime number between a range
|
||||
*
|
||||
* If there's not a prime within the given range, false will be returned.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32|false
|
||||
*/
|
||||
public static function randomRangePrime(PHP32 $min, PHP32 $max)
|
||||
{
|
||||
return self::randomRangePrimeOuter($min, $max);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random number between a range
|
||||
*
|
||||
* Returns a random number between $min and $max where $min and $max
|
||||
* can be defined using one of the two methods:
|
||||
*
|
||||
* BigInteger::randomRange($min, $max)
|
||||
* BigInteger::randomRange($max, $min)
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\Engine\PHP32
|
||||
*/
|
||||
public static function randomRange(PHP32 $min, PHP32 $max)
|
||||
{
|
||||
return self::randomRangeHelper($min, $max);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function pow(PHP32 $n)
|
||||
{
|
||||
return $this->powHelper($n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the minimum BigInteger between an arbitrary number of BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public static function min(PHP32 ...$nums)
|
||||
{
|
||||
return self::minHelper($nums);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the maximum BigInteger between an arbitrary number of BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP32
|
||||
*/
|
||||
public static function max(PHP32 ...$nums)
|
||||
{
|
||||
return self::maxHelper($nums);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests BigInteger to see if it is between two integers, inclusive
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function between(PHP32 $min, PHP32 $max)
|
||||
{
|
||||
return $this->compare($min) >= 0 && $this->compare($max) <= 0;
|
||||
}
|
||||
}
|
||||
343
phpseclib/Math/BigInteger/Engines/PHP64.php
Normal file
343
phpseclib/Math/BigInteger/Engines/PHP64.php
Normal file
@ -0,0 +1,343 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Pure-PHP 64-bit BigInteger Engine
|
||||
*
|
||||
* PHP version 5 and 7
|
||||
*
|
||||
* @category Math
|
||||
* @package BigInteger
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2017 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://pear.php.net/package/Math_BigInteger
|
||||
*/
|
||||
|
||||
namespace phpseclib\Math\BigInteger\Engines;
|
||||
|
||||
use ParagonIE\ConstantTime\Hex;
|
||||
|
||||
/**
|
||||
* Pure-PHP 64-bit Engine.
|
||||
*
|
||||
* Uses 64-bit integers if int size is 8 bits
|
||||
*
|
||||
* @package PHP
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
class PHP64 extends PHP
|
||||
{
|
||||
/**#@+
|
||||
* Constants used by PHP.php
|
||||
*/
|
||||
const BASE = 31;
|
||||
const BASE_FULL = 0x80000000;
|
||||
const MAX_DIGIT = 0x7FFFFFFF;
|
||||
const MSB = 0x40000000;
|
||||
|
||||
/**
|
||||
* MAX10 in greatest MAX10LEN satisfying
|
||||
* MAX10 = 10**MAX10LEN <= 2**BASE.
|
||||
*/
|
||||
const MAX10 = 1000000000;
|
||||
|
||||
/**
|
||||
* MAX10LEN in greatest MAX10LEN satisfying
|
||||
* MAX10 = 10**MAX10LEN <= 2**BASE.
|
||||
*/
|
||||
const MAX10LEN = 9;
|
||||
const MAX_DIGIT2 = 4611686018427387904;
|
||||
/**#@-*/
|
||||
|
||||
/**
|
||||
* Modular Exponentiation Engine
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
protected static $modexpEngine;
|
||||
|
||||
/**
|
||||
* Engine Validity Flag
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
protected static $isValidEngine;
|
||||
|
||||
/**
|
||||
* Primes > 2 and < 1000
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
protected static $primes;
|
||||
|
||||
/**
|
||||
* BigInteger(0)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
protected static $zero;
|
||||
|
||||
/**
|
||||
* BigInteger(1)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
protected static $one;
|
||||
|
||||
/**
|
||||
* BigInteger(2)
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
protected static $two;
|
||||
|
||||
/**
|
||||
* Test for engine validity
|
||||
*
|
||||
* @see parent::__construct()
|
||||
* @return bool
|
||||
*/
|
||||
public static function isValidEngine()
|
||||
{
|
||||
return PHP_INT_SIZE >= 8;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function add(PHP64 $y)
|
||||
{
|
||||
$temp = self::addHelper($this->value, $this->is_negative, $y->value, $y->is_negative);
|
||||
|
||||
return $this->convertToObj($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function subtract(PHP64 $y)
|
||||
{
|
||||
$temp = self::subtractHelper($this->value, $this->is_negative, $y->value, $y->is_negative);
|
||||
|
||||
return $this->convertToObj($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Multiplies two BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function multiply(PHP64 $y)
|
||||
{
|
||||
$temp = self::multiplyHelper($this->value, $this->is_negative, $y->value, $y->is_negative);
|
||||
|
||||
return $this->convertToObj($temp);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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).
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function divide(PHP64 $y)
|
||||
{
|
||||
return $this->divideHelper($y);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates modular inverses.
|
||||
*
|
||||
* Say you have (30 mod 17 * x mod 17) mod 17 == 1. x can be found using modular inverses.
|
||||
*/
|
||||
public function modInverse(PHP64 $n)
|
||||
{
|
||||
return $this->modInverseHelper($n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates modular inverses.
|
||||
*
|
||||
* Say you have (30 mod 17 * x mod 17) mod 17 == 1. x can be found using modular inverses.
|
||||
*/
|
||||
public function extendedGCD(PHP64 $n)
|
||||
{
|
||||
return $this->extendedGCDHelper($n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the greatest common divisor
|
||||
*
|
||||
* Say you have 693 and 609. The GCD is 21.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function gcd(PHP64 $n)
|
||||
{
|
||||
extract($this->extendedGCD($n));
|
||||
return $gcd;
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical And
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function bitwise_and(PHP64 $x)
|
||||
{
|
||||
return $this->bitwiseAndHelper($x);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Or
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function bitwise_or(PHP64 $x)
|
||||
{
|
||||
return $this->bitwiseOrHelper($x);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logical Exlusive Or
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function bitwise_xor(PHP64 $x)
|
||||
{
|
||||
return $this->bitwiseXorHelper($x);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares two numbers.
|
||||
*
|
||||
* Although one might think !$x->compare($y) means $x != $y, it, in fact, means the opposite. The reason for this is
|
||||
* demonstrated thusly:
|
||||
*
|
||||
* $x > $y: $x->compare($y) > 0
|
||||
* $x < $y: $x->compare($y) < 0
|
||||
* $x == $y: $x->compare($y) == 0
|
||||
*
|
||||
* Note how the same comparison operator is used. If you want to test for equality, use $x->equals($y).
|
||||
*
|
||||
* @return int < 0 if $this is less than $y; > 0 if $this is greater than $y, and 0 if they are equal.
|
||||
* @access public
|
||||
* @see self::equals()
|
||||
* @internal Could return $this->subtract($x), but that's not as fast as what we do do.
|
||||
*/
|
||||
public function compare(PHP64 $y)
|
||||
{
|
||||
return parent::compareHelper($this->value, $this->is_negative, $y->value, $y->is_negative);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the equality of two numbers.
|
||||
*
|
||||
* If you need to see if one number is greater than or less than another number, use BigInteger::compare()
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function equals(PHP64 $x)
|
||||
{
|
||||
return $this->value === $x->value && $this->is_negative == $x->is_negative;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function modPow(PHP64 $e, PHP64 $n)
|
||||
{
|
||||
return $this->powModOuter($e, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs modular exponentiation.
|
||||
*
|
||||
* Alias for modPow().
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function powMod(PHP64 $e, PHP64 $n)
|
||||
{
|
||||
return $this->powModOuter($e, $n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random prime number between a range
|
||||
*
|
||||
* If there's not a prime within the given range, false will be returned.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64|false
|
||||
*/
|
||||
public static function randomRangePrime(PHP64 $min, PHP64 $max)
|
||||
{
|
||||
return self::randomRangePrimeOuter($min, $max);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a random number between a range
|
||||
*
|
||||
* Returns a random number between $min and $max where $min and $max
|
||||
* can be defined using one of the two methods:
|
||||
*
|
||||
* BigInteger::randomRange($min, $max)
|
||||
* BigInteger::randomRange($max, $min)
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\Engine\PHP64
|
||||
*/
|
||||
public static function randomRange(PHP64 $min, PHP64 $max)
|
||||
{
|
||||
return self::randomRangeHelper($min, $max);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs exponentiation.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public function pow(PHP64 $n)
|
||||
{
|
||||
return $this->powHelper($n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the minimum BigInteger between an arbitrary number of BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public static function min(PHP64 ...$nums)
|
||||
{
|
||||
return self::minHelper($nums);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the maximum BigInteger between an arbitrary number of BigIntegers.
|
||||
*
|
||||
* @return \phpseclib\Math\BigInteger\Engines\PHP64
|
||||
*/
|
||||
public static function max(PHP64 ...$nums)
|
||||
{
|
||||
return self::maxHelper($nums);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests BigInteger to see if it is between two integers, inclusive
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function between(PHP64 $min, PHP64 $max)
|
||||
{
|
||||
return $this->compare($min) >= 0 && $this->compare($max) <= 0;
|
||||
}
|
||||
}
|
||||
@ -10,29 +10,6 @@ use phpseclib\Math\BigInteger;
|
||||
|
||||
abstract class PhpseclibFunctionalTestCase extends PhpseclibTestCase
|
||||
{
|
||||
public static function setUpBeforeClass()
|
||||
{
|
||||
if (extension_loaded('runkit')) {
|
||||
if (extension_loaded('gmp')) {
|
||||
self::ensureConstant(
|
||||
'MATH_BIGINTEGER_MODE',
|
||||
BigInteger::MODE_GMP
|
||||
);
|
||||
} elseif (extension_loaded('bcmath')) {
|
||||
self::ensureConstant(
|
||||
'MATH_BIGINTEGER_MODE',
|
||||
BigInteger::MODE_BCMATH
|
||||
);
|
||||
} else {
|
||||
self::markTestSkipped(
|
||||
'Should have gmp or bcmath extension for functional test.'
|
||||
);
|
||||
}
|
||||
self::reRequireFile('Math/BigInteger.php');
|
||||
}
|
||||
parent::setUpBeforeClass();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $variable
|
||||
* @param string|null $message
|
||||
|
||||
@ -5,16 +5,25 @@
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
use \phpseclib\Math\BigInteger\Engines\BCMath;
|
||||
|
||||
class Unit_Math_BigInteger_BCMathTest extends Unit_Math_BigInteger_TestCase
|
||||
{
|
||||
public static function setUpBeforeClass()
|
||||
{
|
||||
if (!extension_loaded('bcmath')) {
|
||||
if (!BCMath::isValidEngine()) {
|
||||
self::markTestSkipped('BCMath extension is not available.');
|
||||
}
|
||||
BCMath::setModExpEngine('DefaultEngine');
|
||||
}
|
||||
|
||||
parent::setUpBeforeClass();
|
||||
public function getInstance($x = 0, $base = 10)
|
||||
{
|
||||
return new BCMath($x, $base);
|
||||
}
|
||||
|
||||
self::ensureConstant('MATH_BIGINTEGER_MODE', \phpseclib\Math\BigInteger::MODE_BCMATH);
|
||||
public static function getStaticClass()
|
||||
{
|
||||
return 'phpseclib\Math\BigInteger\Engines\BCMath';
|
||||
}
|
||||
}
|
||||
|
||||
21
tests/Unit/Math/BigInteger/DefaultTest.php
Normal file
21
tests/Unit/Math/BigInteger/DefaultTest.php
Normal file
@ -0,0 +1,21 @@
|
||||
<?php
|
||||
/**
|
||||
* @author Andreas Fischer <bantu@phpbb.com>
|
||||
* @copyright 2013 Andreas Fischer
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
use \phpseclib\Math\BigInteger;
|
||||
|
||||
class Unit_Math_BigInteger_DefaultTest extends Unit_Math_BigInteger_TestCase
|
||||
{
|
||||
public function getInstance($x = 0, $base = 10)
|
||||
{
|
||||
return new BigInteger($x, $base);
|
||||
}
|
||||
|
||||
public static function getStaticClass()
|
||||
{
|
||||
return 'phpseclib\Math\BigInteger';
|
||||
}
|
||||
}
|
||||
@ -5,16 +5,25 @@
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
use \phpseclib\Math\BigInteger\Engines\GMP;
|
||||
|
||||
class Unit_Math_BigInteger_GMPTest extends Unit_Math_BigInteger_TestCase
|
||||
{
|
||||
public static function setUpBeforeClass()
|
||||
{
|
||||
if (!extension_loaded('gmp')) {
|
||||
if (!GMP::isValidEngine()) {
|
||||
self::markTestSkipped('GNU Multiple Precision (GMP) extension is not available.');
|
||||
}
|
||||
GMP::setModExpEngine('DefaultEngine');
|
||||
}
|
||||
|
||||
parent::setUpBeforeClass();
|
||||
public function getInstance($x = 0, $base = 10)
|
||||
{
|
||||
return new GMP($x, $base);
|
||||
}
|
||||
|
||||
self::ensureConstant('MATH_BIGINTEGER_MODE', \phpseclib\Math\BigInteger::MODE_GMP);
|
||||
public static function getStaticClass()
|
||||
{
|
||||
return 'phpseclib\Math\BigInteger\Engines\GMP';
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,25 +0,0 @@
|
||||
<?php
|
||||
/**
|
||||
* @author Andreas Fischer <bantu@phpbb.com>
|
||||
* @copyright 2013 Andreas Fischer
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
class Unit_Math_BigInteger_InternalTest extends Unit_Math_BigInteger_TestCase
|
||||
{
|
||||
public static function setUpBeforeClass()
|
||||
{
|
||||
parent::setUpBeforeClass();
|
||||
|
||||
self::ensureConstant('MATH_BIGINTEGER_MODE', \phpseclib\Math\BigInteger::MODE_INTERNAL);
|
||||
self::ensureConstant('MATH_BIGINTEGER_OPENSSL_DISABLE', true);
|
||||
}
|
||||
|
||||
public function testInternalRepresentation()
|
||||
{
|
||||
$x = new \phpseclib\Math\BigInteger('FFFFFFFFFFFFFFFFC90FDA', 16);
|
||||
$y = new \phpseclib\Math\BigInteger("$x");
|
||||
|
||||
$this->assertSame(self::getVar($x, 'value'), self::getVar($y, 'value'));
|
||||
}
|
||||
}
|
||||
37
tests/Unit/Math/BigInteger/PHP32Test.php
Normal file
37
tests/Unit/Math/BigInteger/PHP32Test.php
Normal file
@ -0,0 +1,37 @@
|
||||
<?php
|
||||
/**
|
||||
* @author Andreas Fischer <bantu@phpbb.com>
|
||||
* @copyright 2013 Andreas Fischer
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
use \phpseclib\Math\BigInteger\Engines\PHP32;
|
||||
|
||||
class Unit_Math_BigInteger_PHP32Test extends Unit_Math_BigInteger_TestCase
|
||||
{
|
||||
public static function setUpBeforeClass()
|
||||
{
|
||||
if (version_compare(PHP_VERSION, '7.0.0') < 0) {
|
||||
self::markTestSkipped('32-bit integers slow things down too much on PHP 5.6');
|
||||
}
|
||||
PHP32::setModExpEngine('DefaultEngine');
|
||||
}
|
||||
|
||||
public function getInstance($x = 0, $base = 10)
|
||||
{
|
||||
return new PHP32($x, $base);
|
||||
}
|
||||
|
||||
public function testInternalRepresentation()
|
||||
{
|
||||
$x = new PHP32('FFFFFFFFFFFFFFFFC90FDA', 16);
|
||||
$y = new PHP32("$x");
|
||||
|
||||
$this->assertSame(self::getVar($x, 'value'), self::getVar($y, 'value'));
|
||||
}
|
||||
|
||||
public static function getStaticClass()
|
||||
{
|
||||
return 'phpseclib\Math\BigInteger\Engines\PHP32';
|
||||
}
|
||||
}
|
||||
@ -5,16 +5,18 @@
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
class Unit_Math_BigInteger_InternalOpenSSLTest extends Unit_Math_BigInteger_TestCase
|
||||
use \phpseclib\Math\BigInteger\Engines\PHP64;
|
||||
|
||||
class Unit_Math_BigInteger_PHP64OpenSSLTest extends Unit_Math_BigInteger_PHP64Test
|
||||
{
|
||||
public static function setUpBeforeClass()
|
||||
{
|
||||
if (!extension_loaded('openssl')) {
|
||||
self::markTestSkipped('openssl_public_encrypt() function is not available.');
|
||||
}
|
||||
|
||||
parent::setUpBeforeClass();
|
||||
|
||||
self::ensureConstant('MATH_BIGINTEGER_MODE', \phpseclib\Math\BigInteger::MODE_INTERNAL);
|
||||
try {
|
||||
PHP64::setModExpEngine('OpenSSL');
|
||||
} catch (BadConfigurationException $e) {
|
||||
self::markTestSkipped('openssl_public_encrypt() function is not available.');
|
||||
}
|
||||
}
|
||||
}
|
||||
37
tests/Unit/Math/BigInteger/PHP64Test.php
Normal file
37
tests/Unit/Math/BigInteger/PHP64Test.php
Normal file
@ -0,0 +1,37 @@
|
||||
<?php
|
||||
/**
|
||||
* @author Andreas Fischer <bantu@phpbb.com>
|
||||
* @copyright 2013 Andreas Fischer
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
use \phpseclib\Math\BigInteger\Engines\PHP64;
|
||||
|
||||
class Unit_Math_BigInteger_PHP64Test extends Unit_Math_BigInteger_TestCase
|
||||
{
|
||||
public static function setUpBeforeClass()
|
||||
{
|
||||
if (!PHP64::isValidEngine()) {
|
||||
self::markTestSkipped('64-bit integers are not available.');
|
||||
}
|
||||
PHP64::setModExpEngine('DefaultEngine');
|
||||
}
|
||||
|
||||
public function getInstance($x = 0, $base = 10)
|
||||
{
|
||||
return new PHP64($x, $base);
|
||||
}
|
||||
|
||||
public function testInternalRepresentation()
|
||||
{
|
||||
$x = new PHP64('FFFFFFFFFFFFFFFFC90FDA', 16);
|
||||
$y = new PHP64("$x");
|
||||
|
||||
$this->assertSame(self::getVar($x, 'value'), self::getVar($y, 'value'));
|
||||
}
|
||||
|
||||
public static function getStaticClass()
|
||||
{
|
||||
return 'phpseclib\Math\BigInteger\Engines\PHP64';
|
||||
}
|
||||
}
|
||||
@ -7,17 +7,6 @@
|
||||
|
||||
abstract class Unit_Math_BigInteger_TestCase extends PhpseclibTestCase
|
||||
{
|
||||
public static function setUpBeforeClass()
|
||||
{
|
||||
parent::setUpBeforeClass();
|
||||
self::reRequireFile('Math/BigInteger.php');
|
||||
}
|
||||
|
||||
public function getInstance($x = 0, $base = 10)
|
||||
{
|
||||
return new \phpseclib\Math\BigInteger($x, $base);
|
||||
}
|
||||
|
||||
public function testConstructorBase2()
|
||||
{
|
||||
// 2**65 = 36893488147419103232
|
||||
@ -273,7 +262,8 @@ abstract class Unit_Math_BigInteger_TestCase extends PhpseclibTestCase
|
||||
$min = $this->getInstance(0);
|
||||
$max = $this->getInstance('18446744073709551616');
|
||||
|
||||
$rand1 = \phpseclib\Math\BigInteger::randomRange($min, $max);
|
||||
$class = static::getStaticClass();
|
||||
$rand1 = $class::randomRange($min, $max);
|
||||
// technically $rand1 can equal $min but with the $min and $max we've
|
||||
// chosen it's just not that likely
|
||||
$this->assertTrue($rand1->compare($min) > 0);
|
||||
@ -285,14 +275,6 @@ abstract class Unit_Math_BigInteger_TestCase extends PhpseclibTestCase
|
||||
*/
|
||||
public function testDiffieHellmanKeyAgreement()
|
||||
{
|
||||
if (getenv('TRAVIS') && PHP_VERSION === '5.3.3'
|
||||
&& MATH_BIGINTEGER_MODE === \phpseclib\Math\BigInteger::MODE_INTERNAL
|
||||
) {
|
||||
$this->markTestIncomplete(
|
||||
'This test hangs on PHP 5.3.3 using internal mode.'
|
||||
);
|
||||
}
|
||||
|
||||
// "Oakley Group 14" 2048-bit modular exponentiation group as used in
|
||||
// SSH2 diffie-hellman-group14-sha1
|
||||
$prime = $this->getInstance(
|
||||
@ -313,10 +295,11 @@ abstract class Unit_Math_BigInteger_TestCase extends PhpseclibTestCase
|
||||
|
||||
/*
|
||||
Code for generation of $alicePrivate and $bobPrivate.
|
||||
$class = static::getStaticClass();
|
||||
$one = $this->getInstance(1);
|
||||
$max = $one->bitwise_leftShift(512)->subtract($one);
|
||||
$alicePrivate = \phpseclib\Math\BigInteger::randomRange($one, $max);
|
||||
$bobPrivate = \phpseclib\Math\BigInteger::randomRange($one, $max);
|
||||
$alicePrivate = $static::randomRange($one, $max);
|
||||
$bobPrivate = $static::randomRange($one, $max);
|
||||
var_dump($alicePrivate->toHex(), $bobPrivate->toHex());
|
||||
*/
|
||||
|
||||
@ -382,19 +365,18 @@ abstract class Unit_Math_BigInteger_TestCase extends PhpseclibTestCase
|
||||
}
|
||||
public function testRoot()
|
||||
{
|
||||
$bigInteger = new \phpseclib\Math\BigInteger('64000000'); // (20^2)^3
|
||||
$three = new \phpseclib\Math\BigInteger('3');
|
||||
$bigInteger = $this->getInstance('64000000'); // (20^2)^3
|
||||
$bigInteger = $bigInteger->root();
|
||||
$this->assertSame('8000', (string) $bigInteger);
|
||||
$bigInteger = $bigInteger->root($three);
|
||||
$bigInteger = $bigInteger->root(3);
|
||||
$this->assertSame('20', (string) $bigInteger);
|
||||
}
|
||||
|
||||
public function testPow()
|
||||
{
|
||||
$bigInteger = new \phpseclib\Math\BigInteger('20');
|
||||
$two = new \phpseclib\Math\BigInteger('2');
|
||||
$three = new \phpseclib\Math\BigInteger('3');
|
||||
$bigInteger = $this->getInstance('20');
|
||||
$two = $this->getInstance('2');
|
||||
$three = $this->getInstance('3');
|
||||
$bigInteger = $bigInteger->pow($two);
|
||||
$this->assertSame('400', (string) $bigInteger);
|
||||
$bigInteger = $bigInteger->pow($three);
|
||||
@ -403,17 +385,19 @@ abstract class Unit_Math_BigInteger_TestCase extends PhpseclibTestCase
|
||||
|
||||
public function testMax()
|
||||
{
|
||||
$min = new \phpseclib\Math\BigInteger('20');
|
||||
$max = new \phpseclib\Math\BigInteger('20000');
|
||||
$this->assertSame((string) $max, (string) \phpseclib\Math\BigInteger::max($min, $max));
|
||||
$this->assertSame((string) $max, (string) \phpseclib\Math\BigInteger::max($max, $min));
|
||||
$class = static::getStaticClass();
|
||||
$min = $this->getInstance('20');
|
||||
$max = $this->getInstance('20000');
|
||||
$this->assertSame((string) $max, (string) $class::max($min, $max));
|
||||
$this->assertSame((string) $max, (string) $class::max($max, $min));
|
||||
}
|
||||
|
||||
public function testMin()
|
||||
{
|
||||
$min = new \phpseclib\Math\BigInteger('20');
|
||||
$max = new \phpseclib\Math\BigInteger('20000');
|
||||
$this->assertSame((string) $min, (string) \phpseclib\Math\BigInteger::min($min, $max));
|
||||
$this->assertSame((string) $min, (string) \phpseclib\Math\BigInteger::min($max, $min));
|
||||
$class = static::getStaticClass();
|
||||
$min = $this->getInstance('20');
|
||||
$max = $this->getInstance('20000');
|
||||
$this->assertSame((string) $min, (string) $class::min($min, $max));
|
||||
$this->assertSame((string) $min, (string) $class::min($max, $min));
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user