WebSVN – oidplus – Diff – /trunk/includes/gmp_supplement.inc.php

 <?php
 /*
  * PHP GMP-Supplement implemented using BCMath
  * Copyright 2020 Daniel Marschall, ViaThinkSoft
- * Version 2020-04-07
+ * Version 2020-09-12
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
+ *
                 // gmp_divexact ( GMP $n , GMP $d ) : GMP
                 // Exact division of numbers
                 function gmp_divexact($n, $d) {
                         bcscale(0);
-                        return bcdiv($a, $b);
+                        return bcdiv($n, $d);
+                }
                 // gmp_export ( GMP $gmpnumber [, int $word_size = 1 [, int $options = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN ]] ) : string
                 // Export to a binary string
                 function gmp_export($gmpnumber, $word_size = 1, $options = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN) {
                                 $t = $t_;
                                 $t_ = bcsub($temp, bcmul($t, $q, 0), 0);
+                        }
                         return [
-                                'g' => $this->normalize($a),
+                                'g' => /*$this->normalize*/($a),
-                                's' => $this->normalize($s),
+                                's' => /*$this->normalize*/($s),
-                                't' => $this->normalize($t)
+                                't' => /*$this->normalize*/($t)
                         ];
+                }
                 // gmp_hamdist ( GMP $a , GMP $b ) : int
                 // Hamming distance
                         bcscale(0);
                         // Source: https://github.com/CityOfZion/neo-php/blob/master/src/Crypto/NumberTheory.php#L246
                         while (bccomp($a, 0)==-1) {
-                                $a=bcadd($m, $a);
+                                $a=bcadd($b, $a);
+                        }
-                        while (bccomp($m, $a)==-1) {
+                        while (bccomp($b, $a)==-1) {
-                                $a=bcmod($a, $m);
+                                $a=bcmod($a, $b);
+                        }
                         $c=$a;
-                        $d=$m;
+                        $d=$b;
                         $uc=1;
                         $vc=0;
                         $ud=0;
                         $vd=1;
                         while (bccomp($c, 0)!=0) {
                         $result='';
                         if (bccomp($d, 1)==0) {
                                 if (bccomp($ud, 0)==1) {
                                         $result=$ud;
                                 } else {
-                                        $result=bcadd($ud, $m);
+                                        $result=bcadd($ud, $b);
+                                }
                         } else {
-                                throw new ErrorException("ERROR: $a and $m are NOT relatively prime.");
+                                throw new ErrorException("ERROR: $a and $b are NOT relatively prime.");
+                        }
                         return $result;
+                }
                 // gmp_jacobi ( GMP $a , GMP $p ) : int
                 function gmp_jacobi($a, $p) {
                         bcscale(0);
                         // Source: https://github.com/CityOfZion/neo-php/blob/master/src/Crypto/NumberTheory.php#L136
-                        if ($n>=3 && $n%2==1) {
+                        if ($p>=3 && $p%2==1) {
-                                $a = bcmod($a, $n);
+                                $a = bcmod($a, $p);
                                 if ($a == 0) return 0;
                                 if ($a == 1) return 1;
                                 $a1 = $a;
                                 $e = 0;
                                 while (bcmod($a1, 2) == 0) {
                                         $a1 = bcdiv($a1, 2);
                                         $e = bcadd($e, 1);
+                                }
-                                $s = (bcmod($e, 2)==0 || bcmod($n, 8)==1 || bcmod($n, 8)==7) ? 1 : -1;
+                                $s = (bcmod($e, 2)==0 || bcmod($p, 8)==1 || bcmod($p, 8)==7) ? 1 : -1;
                                 if ($a1 == 1) return $s;
-                                if (bcmod($n, 4)==3 && bcmod($a1, 4)==3) $s = -$s;
+                                if (bcmod($p, 4)==3 && bcmod($a1, 4)==3) $s = -$s;
-                                return bcmul($s, gmp_jacobi(bcmod($n, $a1), $a1));
+                                return bcmul($s, gmp_jacobi(bcmod($p, $a1), $a1));
                         } else {
                                 return false;
+                        }
+                }
                 function gmp_nextprime($a) {
                         bcscale(0);
                         // Source: https://github.com/CityOfZion/neo-php/blob/master/src/Crypto/NumberTheory.php#L692
-                        if (bccomp($starting_value, 2) == -1) {
+                        if (bccomp($a, 2) == -1) {
                                 return 2;
+                        }
-                        $result = gmp_or(bcadd($starting_value, 1), 1);
+                        $result = gmp_or(bcadd($a, 1), 1);
                         while (!gmp_prob_prime($result)) {
                                 $result = bcadd($result, 2);
+                        }
                         return $result;
+                }
                         // Source: https://github.com/CityOfZion/neo-php/blob/master/src/Crypto/NumberTheory.php#L655
                         $t = 40;
                         $k = 0;
-                        $m = bcsub($n, 1);
+                        $m = bcsub($reps, 1);
                         while (bcmod($m, 2) == 0) {
                                 $k = bcadd($k, 1);
                                 $m = bcdiv($m, 2);
+                        }
                         for ($i=0; $i<$t; $i++) {
-                                $a = bcrand(1, bcsub($n, 1));
+                                $a = bcrand(1, bcsub($reps, 1));
                                 if ($m < 0) {
                                         return new ErrorException("Negative exponents ($m) not allowed");
                                 } else {
-                                        $b0 = bcpowmod($a, $m, $n);
+                                        $b0 = bcpowmod($a, $m, $reps);
+                                }
-                                if ($b0!=1 && $b0!=bcsub($n, 1)) {
+                                if ($b0!=1 && $b0!=bcsub($reps, 1)) {
                                         $j = 1;
-                                        while ($j<=$k-1 && $b0!=bcsub($n, 1)) {
+                                        while ($j<=$k-1 && $b0!=bcsub($reps, 1)) {
-                                                $b0 = bcpowmod($b0, 2, $n);
+                                                $b0 = bcpowmod($b0, 2, $reps);
                                                 if ($b0 == 1) {
                                                         return false;
+                                                }
                                                 $j++;
+                                        }
-                                        if ($b0 != bcsub($n, 1)) {
+                                        if ($b0 != bcsub($reps, 1)) {
                                                 return false;
+                                        }
+                                }
+                        }
                         return true;
         // ----------------- New functions -----------------
         // Newly added: gmp_not / bcnot
         function bcnot($a) {
                 bcscale(0);
-                // Convert $a and $b to a binary string
+                // Convert $a to a binary string
                 $ab = bc_dec2bin($a);
-                $bb = bc_dec2bin($b);
-                $length = max(strlen($ab), strlen($bb));
+                $length = strlen($ab);
-                $ab = str_pad($ab, $length, "0", STR_PAD_LEFT);
-                $bb = str_pad($bb, $length, "0", STR_PAD_LEFT);
                 // Do the bitwise binary operation
                 $cb = '';
                 for ($i=0; $i<$length; $i++) {
-                        if ($ab[$i] == 1) return false;
+                        $cb .= ($ab[$i] == 1) ? '0' : '1';
+                }
+                // Convert back to a decimal number
-                return true;
+                return bc_bin2dec($cb);
+        }
         function gmp_not($a) {
                 bcscale(0);
                 return bcnot($a);
+        }

Subversion Repositories oidplus

oidplus/trunk/includes/gmp_supplement.inc.php – Rev 291 → 386