1<?php
2
3/**
4 * Class ParagonIE_Sodium_Core32_Int64
5 *
6 * Encapsulates a 64-bit integer.
7 *
8 * These are immutable. It always returns a new instance.
9 */
10class ParagonIE_Sodium_Core32_Int64
11{
12 /**
13 * @var array<int, int> - four 16-bit integers
14 */
15 public $limbs = array(0, 0, 0, 0);
16
17 /**
18 * @var int
19 */
20 public $overflow = 0;
21
22 /**
23 * @var bool
24 */
25 public $unsignedInt = false;
26
27 /**
28 * ParagonIE_Sodium_Core32_Int64 constructor.
29 * @param array $array
30 * @param bool $unsignedInt
31 */
32 public function __construct($array = array(0, 0, 0, 0), $unsignedInt = false)
33 {
34 $this->limbs = array(
35 (int) $array[0],
36 (int) $array[1],
37 (int) $array[2],
38 (int) $array[3]
39 );
40 $this->overflow = 0;
41 $this->unsignedInt = $unsignedInt;
42 }
43
44 /**
45 * Adds two int64 objects
46 *
47 * @param ParagonIE_Sodium_Core32_Int64 $addend
48 * @return ParagonIE_Sodium_Core32_Int64
49 */
50 public function addInt64(ParagonIE_Sodium_Core32_Int64 $addend)
51 {
52 $i0 = $this->limbs[0];
53 $i1 = $this->limbs[1];
54 $i2 = $this->limbs[2];
55 $i3 = $this->limbs[3];
56 $j0 = $addend->limbs[0];
57 $j1 = $addend->limbs[1];
58 $j2 = $addend->limbs[2];
59 $j3 = $addend->limbs[3];
60
61 $r3 = $i3 + ($j3 & 0xffff);
62 $carry = $r3 >> 16;
63
64 $r2 = $i2 + ($j2 & 0xffff) + $carry;
65 $carry = $r2 >> 16;
66
67 $r1 = $i1 + ($j1 & 0xffff) + $carry;
68 $carry = $r1 >> 16;
69
70 $r0 = $i0 + ($j0 & 0xffff) + $carry;
71 $carry = $r0 >> 16;
72
73 $r0 &= 0xffff;
74 $r1 &= 0xffff;
75 $r2 &= 0xffff;
76 $r3 &= 0xffff;
77
78 $return = new ParagonIE_Sodium_Core32_Int64(
79 array($r0, $r1, $r2, $r3)
80 );
81 $return->overflow = $carry;
82 $return->unsignedInt = $this->unsignedInt;
83 return $return;
84 }
85
86 /**
87 * Adds a normal integer to an int64 object
88 *
89 * @param int $int
90 * @return ParagonIE_Sodium_Core32_Int64
91 * @throws SodiumException
92 * @throws TypeError
93 */
94 public function addInt($int)
95 {
96 ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
97 /** @var int $int */
98 $int = (int) $int;
99
100 $i0 = $this->limbs[0];
101 $i1 = $this->limbs[1];
102 $i2 = $this->limbs[2];
103 $i3 = $this->limbs[3];
104
105 $r3 = $i3 + ($int & 0xffff);
106 $carry = $r3 >> 16;
107
108 $r2 = $i2 + (($int >> 16) & 0xffff) + $carry;
109 $carry = $r2 >> 16;
110
111 $r1 = $i1 + $carry;
112 $carry = $r1 >> 16;
113
114 $r0 = $i0 + $carry;
115 $carry = $r0 >> 16;
116
117 $r0 &= 0xffff;
118 $r1 &= 0xffff;
119 $r2 &= 0xffff;
120 $r3 &= 0xffff;
121 $return = new ParagonIE_Sodium_Core32_Int64(
122 array($r0, $r1, $r2, $r3)
123 );
124 $return->overflow = $carry;
125 $return->unsignedInt = $this->unsignedInt;
126 return $return;
127 }
128
129 /**
130 * @param int $b
131 * @return int
132 */
133 public function compareInt($b = 0)
134 {
135 $gt = 0;
136 $eq = 1;
137
138 $i = 4;
139 $j = 0;
140 while ($i > 0) {
141 --$i;
142 /** @var int $x1 */
143 $x1 = $this->limbs[$i];
144 /** @var int $x2 */
145 $x2 = ($b >> ($j << 4)) & 0xffff;
146 /** int */
147 $gt |= (($x2 - $x1) >> 8) & $eq;
148 /** int */
149 $eq &= (($x2 ^ $x1) - 1) >> 8;
150 }
151 return ($gt + $gt - $eq) + 1;
152 }
153
154 /**
155 * @param int $b
156 * @return bool
157 */
158 public function isGreaterThan($b = 0)
159 {
160 return $this->compareInt($b) > 0;
161 }
162
163 /**
164 * @param int $b
165 * @return bool
166 */
167 public function isLessThanInt($b = 0)
168 {
169 return $this->compareInt($b) < 0;
170 }
171
172 /**
173 * @param int $hi
174 * @param int $lo
175 * @return ParagonIE_Sodium_Core32_Int64
176 */
177 public function mask64($hi = 0, $lo = 0)
178 {
179 /** @var int $a */
180 $a = ($hi >> 16) & 0xffff;
181 /** @var int $b */
182 $b = ($hi) & 0xffff;
183 /** @var int $c */
184 $c = ($lo >> 16) & 0xffff;
185 /** @var int $d */
186 $d = ($lo & 0xffff);
187 return new ParagonIE_Sodium_Core32_Int64(
188 array(
189 $this->limbs[0] & $a,
190 $this->limbs[1] & $b,
191 $this->limbs[2] & $c,
192 $this->limbs[3] & $d
193 ),
194 $this->unsignedInt
195 );
196 }
197
198 /**
199 * @param int $int
200 * @param int $size
201 * @return ParagonIE_Sodium_Core32_Int64
202 * @throws SodiumException
203 * @throws TypeError
204 * @psalm-suppress MixedAssignment
205 */
206 public function mulInt($int = 0, $size = 0)
207 {
208 if (ParagonIE_Sodium_Compat::$fastMult) {
209 return $this->mulIntFast($int);
210 }
211 ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
212 ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
213 /** @var int $int */
214 $int = (int) $int;
215 /** @var int $size */
216 $size = (int) $size;
217
218 if (!$size) {
219 $size = 63;
220 }
221
222 $a = clone $this;
223 $return = new ParagonIE_Sodium_Core32_Int64();
224 $return->unsignedInt = $this->unsignedInt;
225
226 // Initialize:
227 $ret0 = 0;
228 $ret1 = 0;
229 $ret2 = 0;
230 $ret3 = 0;
231 $a0 = $a->limbs[0];
232 $a1 = $a->limbs[1];
233 $a2 = $a->limbs[2];
234 $a3 = $a->limbs[3];
235
236 /** @var int $size */
237 /** @var int $i */
238 for ($i = $size; $i >= 0; --$i) {
239 $mask = -($int & 1);
240 $x0 = $a0 & $mask;
241 $x1 = $a1 & $mask;
242 $x2 = $a2 & $mask;
243 $x3 = $a3 & $mask;
244
245 $ret3 += $x3;
246 $c = $ret3 >> 16;
247
248 $ret2 += $x2 + $c;
249 $c = $ret2 >> 16;
250
251 $ret1 += $x1 + $c;
252 $c = $ret1 >> 16;
253
254 $ret0 += $x0 + $c;
255
256 $ret0 &= 0xffff;
257 $ret1 &= 0xffff;
258 $ret2 &= 0xffff;
259 $ret3 &= 0xffff;
260
261 $a3 = $a3 << 1;
262 $x3 = $a3 >> 16;
263 $a2 = ($a2 << 1) | $x3;
264 $x2 = $a2 >> 16;
265 $a1 = ($a1 << 1) | $x2;
266 $x1 = $a1 >> 16;
267 $a0 = ($a0 << 1) | $x1;
268 $a0 &= 0xffff;
269 $a1 &= 0xffff;
270 $a2 &= 0xffff;
271 $a3 &= 0xffff;
272
273 $int >>= 1;
274 }
275 $return->limbs[0] = $ret0;
276 $return->limbs[1] = $ret1;
277 $return->limbs[2] = $ret2;
278 $return->limbs[3] = $ret3;
279 return $return;
280 }
281
282 /**
283 * @param ParagonIE_Sodium_Core32_Int64 $A
284 * @param ParagonIE_Sodium_Core32_Int64 $B
285 * @return array<int, ParagonIE_Sodium_Core32_Int64>
286 * @throws SodiumException
287 * @throws TypeError
288 * @psalm-suppress MixedInferredReturnType
289 */
290 public static function ctSelect(
291 ParagonIE_Sodium_Core32_Int64 $A,
292 ParagonIE_Sodium_Core32_Int64 $B
293 ) {
294 $a = clone $A;
295 $b = clone $B;
296 /** @var int $aNeg */
297 $aNeg = ($a->limbs[0] >> 15) & 1;
298 /** @var int $bNeg */
299 $bNeg = ($b->limbs[0] >> 15) & 1;
300 /** @var int $m */
301 $m = (-($aNeg & $bNeg)) | 1;
302 /** @var int $swap */
303 $swap = $bNeg & ~$aNeg;
304 /** @var int $d */
305 $d = -$swap;
306
307 /*
308 if ($bNeg && !$aNeg) {
309 $a = clone $int;
310 $b = clone $this;
311 } elseif($bNeg && $aNeg) {
312 $a = $this->mulInt(-1);
313 $b = $int->mulInt(-1);
314 }
315 */
316 $x = $a->xorInt64($b)->mask64($d, $d);
317 return array(
318 $a->xorInt64($x)->mulInt($m),
319 $b->xorInt64($x)->mulInt($m)
320 );
321 }
322
323 /**
324 * @param array<int, int> $a
325 * @param array<int, int> $b
326 * @param int $baseLog2
327 * @return array<int, int>
328 */
329 public function multiplyLong(array $a, array $b, $baseLog2 = 16)
330 {
331 $a_l = count($a);
332 $b_l = count($b);
333 /** @var array<int, int> $r */
334 $r = array_fill(0, $a_l + $b_l + 1, 0);
335 $base = 1 << $baseLog2;
336 for ($i = 0; $i < $a_l; ++$i) {
337 $a_i = $a[$i];
338 for ($j = 0; $j < $a_l; ++$j) {
339 $b_j = $b[$j];
340 $product = (($a_i * $b_j) + $r[$i + $j]);
341 $carry = (((int) $product >> $baseLog2) & 0xffff);
342 $r[$i + $j] = ((int) $product - (int) ($carry * $base)) & 0xffff;
343 $r[$i + $j + 1] += $carry;
344 }
345 }
346 return array_slice($r, 0, 5);
347 }
348
349 /**
350 * @param int $int
351 * @return ParagonIE_Sodium_Core32_Int64
352 */
353 public function mulIntFast($int)
354 {
355 // Handle negative numbers
356 $aNeg = ($this->limbs[0] >> 15) & 1;
357 $bNeg = ($int >> 31) & 1;
358 $a = array_reverse($this->limbs);
359 $b = array(
360 $int & 0xffff,
361 ($int >> 16) & 0xffff,
362 -$bNeg & 0xffff,
363 -$bNeg & 0xffff
364 );
365 if ($aNeg) {
366 for ($i = 0; $i < 4; ++$i) {
367 $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
368 }
369 ++$a[0];
370 }
371 if ($bNeg) {
372 for ($i = 0; $i < 4; ++$i) {
373 $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
374 }
375 ++$b[0];
376 }
377 // Multiply
378 $res = $this->multiplyLong($a, $b);
379
380 // Re-apply negation to results
381 if ($aNeg !== $bNeg) {
382 for ($i = 0; $i < 4; ++$i) {
383 $res[$i] = (0xffff ^ $res[$i]) & 0xffff;
384 }
385 // Handle integer overflow
386 $c = 1;
387 for ($i = 0; $i < 4; ++$i) {
388 $res[$i] += $c;
389 $c = $res[$i] >> 16;
390 $res[$i] &= 0xffff;
391 }
392 }
393
394 // Return our values
395 $return = new ParagonIE_Sodium_Core32_Int64();
396 $return->limbs = array(
397 $res[3] & 0xffff,
398 $res[2] & 0xffff,
399 $res[1] & 0xffff,
400 $res[0] & 0xffff
401 );
402 if (count($res) > 4) {
403 $return->overflow = $res[4] & 0xffff;
404 }
405 $return->unsignedInt = $this->unsignedInt;
406 return $return;
407 }
408
409 /**
410 * @param ParagonIE_Sodium_Core32_Int64 $right
411 * @return ParagonIE_Sodium_Core32_Int64
412 */
413 public function mulInt64Fast(ParagonIE_Sodium_Core32_Int64 $right)
414 {
415 $aNeg = ($this->limbs[0] >> 15) & 1;
416 $bNeg = ($right->limbs[0] >> 15) & 1;
417
418 $a = array_reverse($this->limbs);
419 $b = array_reverse($right->limbs);
420 if ($aNeg) {
421 for ($i = 0; $i < 4; ++$i) {
422 $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;
423 }
424 ++$a[0];
425 }
426 if ($bNeg) {
427 for ($i = 0; $i < 4; ++$i) {
428 $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;
429 }
430 ++$b[0];
431 }
432 $res = $this->multiplyLong($a, $b);
433 if ($aNeg !== $bNeg) {
434 if ($aNeg !== $bNeg) {
435 for ($i = 0; $i < 4; ++$i) {
436 $res[$i] = ($res[$i] ^ 0xffff) & 0xffff;
437 }
438 $c = 1;
439 for ($i = 0; $i < 4; ++$i) {
440 $res[$i] += $c;
441 $c = $res[$i] >> 16;
442 $res[$i] &= 0xffff;
443 }
444 }
445 }
446 $return = new ParagonIE_Sodium_Core32_Int64();
447 $return->limbs = array(
448 $res[3] & 0xffff,
449 $res[2] & 0xffff,
450 $res[1] & 0xffff,
451 $res[0] & 0xffff
452 );
453 if (count($res) > 4) {
454 $return->overflow = $res[4];
455 }
456 return $return;
457 }
458
459 /**
460 * @param ParagonIE_Sodium_Core32_Int64 $int
461 * @param int $size
462 * @return ParagonIE_Sodium_Core32_Int64
463 * @throws SodiumException
464 * @throws TypeError
465 * @psalm-suppress MixedAssignment
466 */
467 public function mulInt64(ParagonIE_Sodium_Core32_Int64 $int, $size = 0)
468 {
469 if (ParagonIE_Sodium_Compat::$fastMult) {
470 return $this->mulInt64Fast($int);
471 }
472 ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
473 if (!$size) {
474 $size = 63;
475 }
476 list($a, $b) = self::ctSelect($this, $int);
477
478 $return = new ParagonIE_Sodium_Core32_Int64();
479 $return->unsignedInt = $this->unsignedInt;
480
481 // Initialize:
482 $ret0 = 0;
483 $ret1 = 0;
484 $ret2 = 0;
485 $ret3 = 0;
486 $a0 = $a->limbs[0];
487 $a1 = $a->limbs[1];
488 $a2 = $a->limbs[2];
489 $a3 = $a->limbs[3];
490 $b0 = $b->limbs[0];
491 $b1 = $b->limbs[1];
492 $b2 = $b->limbs[2];
493 $b3 = $b->limbs[3];
494
495 /** @var int $size */
496 /** @var int $i */
497 for ($i = (int) $size; $i >= 0; --$i) {
498 $mask = -($b3 & 1);
499 $x0 = $a0 & $mask;
500 $x1 = $a1 & $mask;
501 $x2 = $a2 & $mask;
502 $x3 = $a3 & $mask;
503
504 $ret3 += $x3;
505 $c = $ret3 >> 16;
506
507 $ret2 += $x2 + $c;
508 $c = $ret2 >> 16;
509
510 $ret1 += $x1 + $c;
511 $c = $ret1 >> 16;
512
513 $ret0 += $x0 + $c;
514
515 $ret0 &= 0xffff;
516 $ret1 &= 0xffff;
517 $ret2 &= 0xffff;
518 $ret3 &= 0xffff;
519
520 $a3 = $a3 << 1;
521 $x3 = $a3 >> 16;
522 $a2 = ($a2 << 1) | $x3;
523 $x2 = $a2 >> 16;
524 $a1 = ($a1 << 1) | $x2;
525 $x1 = $a1 >> 16;
526 $a0 = ($a0 << 1) | $x1;
527 $a0 &= 0xffff;
528 $a1 &= 0xffff;
529 $a2 &= 0xffff;
530 $a3 &= 0xffff;
531
532 $x0 = ($b0 & 1) << 16;
533 $x1 = ($b1 & 1) << 16;
534 $x2 = ($b2 & 1) << 16;
535
536 $b0 = ($b0 >> 1);
537 $b1 = (($b1 | $x0) >> 1);
538 $b2 = (($b2 | $x1) >> 1);
539 $b3 = (($b3 | $x2) >> 1);
540
541 $b0 &= 0xffff;
542 $b1 &= 0xffff;
543 $b2 &= 0xffff;
544 $b3 &= 0xffff;
545
546 }
547 $return->limbs[0] = $ret0;
548 $return->limbs[1] = $ret1;
549 $return->limbs[2] = $ret2;
550 $return->limbs[3] = $ret3;
551
552 return $return;
553 }
554
555 /**
556 * OR this 64-bit integer with another.
557 *
558 * @param ParagonIE_Sodium_Core32_Int64 $b
559 * @return ParagonIE_Sodium_Core32_Int64
560 */
561 public function orInt64(ParagonIE_Sodium_Core32_Int64 $b)
562 {
563 $return = new ParagonIE_Sodium_Core32_Int64();
564 $return->unsignedInt = $this->unsignedInt;
565 $return->limbs = array(
566 (int) ($this->limbs[0] | $b->limbs[0]),
567 (int) ($this->limbs[1] | $b->limbs[1]),
568 (int) ($this->limbs[2] | $b->limbs[2]),
569 (int) ($this->limbs[3] | $b->limbs[3])
570 );
571 return $return;
572 }
573
574 /**
575 * @param int $c
576 * @return ParagonIE_Sodium_Core32_Int64
577 * @throws SodiumException
578 * @throws TypeError
579 * @psalm-suppress MixedArrayAccess
580 */
581 public function rotateLeft($c = 0)
582 {
583 ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
584 /** @var int $c */
585 $c = (int) $c;
586
587 $return = new ParagonIE_Sodium_Core32_Int64();
588 $return->unsignedInt = $this->unsignedInt;
589 $c &= 63;
590 if ($c === 0) {
591 // NOP, but we want a copy.
592 $return->limbs = $this->limbs;
593 } else {
594 /** @var array<int, int> $limbs */
595 $limbs =& $return->limbs;
596
597 /** @var array<int, int> $myLimbs */
598 $myLimbs =& $this->limbs;
599
600 /** @var int $idx_shift */
601 $idx_shift = ($c >> 4) & 3;
602 /** @var int $sub_shift */
603 $sub_shift = $c & 15;
604
605 for ($i = 3; $i >= 0; --$i) {
606 /** @var int $j */
607 $j = ($i + $idx_shift) & 3;
608 /** @var int $k */
609 $k = ($i + $idx_shift + 1) & 3;
610 $limbs[$i] = (int) (
611 (
612 ((int) ($myLimbs[$j]) << $sub_shift)
613 |
614 ((int) ($myLimbs[$k]) >> (16 - $sub_shift))
615 ) & 0xffff
616 );
617 }
618 }
619 return $return;
620 }
621
622 /**
623 * Rotate to the right
624 *
625 * @param int $c
626 * @return ParagonIE_Sodium_Core32_Int64
627 * @throws SodiumException
628 * @throws TypeError
629 * @psalm-suppress MixedArrayAccess
630 */
631 public function rotateRight($c = 0)
632 {
633 ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
634 /** @var int $c */
635 $c = (int) $c;
636
637 /** @var ParagonIE_Sodium_Core32_Int64 $return */
638 $return = new ParagonIE_Sodium_Core32_Int64();
639 $return->unsignedInt = $this->unsignedInt;
640 $c &= 63;
641 /** @var int $c */
642 if ($c === 0) {
643 // NOP, but we want a copy.
644 $return->limbs = $this->limbs;
645 } else {
646 /** @var array<int, int> $limbs */
647 $limbs =& $return->limbs;
648
649 /** @var array<int, int> $myLimbs */
650 $myLimbs =& $this->limbs;
651
652 /** @var int $idx_shift */
653 $idx_shift = ($c >> 4) & 3;
654 /** @var int $sub_shift */
655 $sub_shift = $c & 15;
656
657 for ($i = 3; $i >= 0; --$i) {
658 /** @var int $j */
659 $j = ($i - $idx_shift) & 3;
660 /** @var int $k */
661 $k = ($i - $idx_shift - 1) & 3;
662 $limbs[$i] = (int) (
663 (
664 ((int) ($myLimbs[$j]) >> (int) ($sub_shift))
665 |
666 ((int) ($myLimbs[$k]) << (16 - (int) ($sub_shift)))
667 ) & 0xffff
668 );
669 }
670 }
671 return $return;
672 }
673 /**
674 * @param int $c
675 * @return ParagonIE_Sodium_Core32_Int64
676 * @throws SodiumException
677 * @throws TypeError
678 */
679 public function shiftLeft($c = 0)
680 {
681 ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
682 /** @var int $c */
683 $c = (int) $c;
684
685 $return = new ParagonIE_Sodium_Core32_Int64();
686 $return->unsignedInt = $this->unsignedInt;
687 $c &= 63;
688
689 if ($c >= 16) {
690 if ($c >= 48) {
691 $return->limbs = array(
692 $this->limbs[3], 0, 0, 0
693 );
694 } elseif ($c >= 32) {
695 $return->limbs = array(
696 $this->limbs[2], $this->limbs[3], 0, 0
697 );
698 } else {
699 $return->limbs = array(
700 $this->limbs[1], $this->limbs[2], $this->limbs[3], 0
701 );
702 }
703 return $return->shiftLeft($c & 15);
704 }
705 if ($c === 0) {
706 $return->limbs = $this->limbs;
707 } elseif ($c < 0) {
708 /** @var int $c */
709 return $this->shiftRight(-$c);
710 } else {
711 if (!is_int($c)) {
712 throw new TypeError();
713 }
714 /** @var int $carry */
715 $carry = 0;
716 for ($i = 3; $i >= 0; --$i) {
717 /** @var int $tmp */
718 $tmp = ($this->limbs[$i] << $c) | ($carry & 0xffff);
719 $return->limbs[$i] = (int) ($tmp & 0xffff);
720 /** @var int $carry */
721 $carry = $tmp >> 16;
722 }
723 }
724 return $return;
725 }
726
727 /**
728 * @param int $c
729 * @return ParagonIE_Sodium_Core32_Int64
730 * @throws SodiumException
731 * @throws TypeError
732 */
733 public function shiftRight($c = 0)
734 {
735 ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
736 $c = (int) $c;
737 /** @var int $c */
738 $return = new ParagonIE_Sodium_Core32_Int64();
739 $return->unsignedInt = $this->unsignedInt;
740 $c &= 63;
741
742 $negative = -(($this->limbs[0] >> 15) & 1);
743 if ($c >= 16) {
744 if ($c >= 48) {
745 $return->limbs = array(
746 (int) ($negative & 0xffff),
747 (int) ($negative & 0xffff),
748 (int) ($negative & 0xffff),
749 (int) $this->limbs[0]
750 );
751 } elseif ($c >= 32) {
752 $return->limbs = array(
753 (int) ($negative & 0xffff),
754 (int) ($negative & 0xffff),
755 (int) $this->limbs[0],
756 (int) $this->limbs[1]
757 );
758 } else {
759 $return->limbs = array(
760 (int) ($negative & 0xffff),
761 (int) $this->limbs[0],
762 (int) $this->limbs[1],
763 (int) $this->limbs[2]
764 );
765 }
766 return $return->shiftRight($c & 15);
767 }
768
769 if ($c === 0) {
770 $return->limbs = $this->limbs;
771 } elseif ($c < 0) {
772 return $this->shiftLeft(-$c);
773 } else {
774 if (!is_int($c)) {
775 throw new TypeError();
776 }
777 /** @var int $carryRight */
778 $carryRight = ($negative & 0xffff);
779 $mask = (int) (((1 << ($c + 1)) - 1) & 0xffff);
780 for ($i = 0; $i < 4; ++$i) {
781 $return->limbs[$i] = (int) (
782 (($this->limbs[$i] >> $c) | ($carryRight << (16 - $c))) & 0xffff
783 );
784 $carryRight = (int) ($this->limbs[$i] & $mask);
785 }
786 }
787 return $return;
788 }
789
790
791 /**
792 * Subtract a normal integer from an int64 object.
793 *
794 * @param int $int
795 * @return ParagonIE_Sodium_Core32_Int64
796 * @throws SodiumException
797 * @throws TypeError
798 */
799 public function subInt($int)
800 {
801 ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
802 $int = (int) $int;
803
804 $return = new ParagonIE_Sodium_Core32_Int64();
805 $return->unsignedInt = $this->unsignedInt;
806
807 /** @var int $carry */
808 $carry = 0;
809 for ($i = 3; $i >= 0; --$i) {
810 /** @var int $tmp */
811 $tmp = $this->limbs[$i] - (($int >> 16) & 0xffff) + $carry;
812 /** @var int $carry */
813 $carry = $tmp >> 16;
814 $return->limbs[$i] = (int) ($tmp & 0xffff);
815 }
816 return $return;
817 }
818
819 /**
820 * The difference between two Int64 objects.
821 *
822 * @param ParagonIE_Sodium_Core32_Int64 $b
823 * @return ParagonIE_Sodium_Core32_Int64
824 */
825 public function subInt64(ParagonIE_Sodium_Core32_Int64 $b)
826 {
827 $return = new ParagonIE_Sodium_Core32_Int64();
828 $return->unsignedInt = $this->unsignedInt;
829 /** @var int $carry */
830 $carry = 0;
831 for ($i = 3; $i >= 0; --$i) {
832 /** @var int $tmp */
833 $tmp = $this->limbs[$i] - $b->limbs[$i] + $carry;
834 /** @var int $carry */
835 $carry = ($tmp >> 16);
836 $return->limbs[$i] = (int) ($tmp & 0xffff);
837 }
838 return $return;
839 }
840
841 /**
842 * XOR this 64-bit integer with another.
843 *
844 * @param ParagonIE_Sodium_Core32_Int64 $b
845 * @return ParagonIE_Sodium_Core32_Int64
846 */
847 public function xorInt64(ParagonIE_Sodium_Core32_Int64 $b)
848 {
849 $return = new ParagonIE_Sodium_Core32_Int64();
850 $return->unsignedInt = $this->unsignedInt;
851 $return->limbs = array(
852 (int) ($this->limbs[0] ^ $b->limbs[0]),
853 (int) ($this->limbs[1] ^ $b->limbs[1]),
854 (int) ($this->limbs[2] ^ $b->limbs[2]),
855 (int) ($this->limbs[3] ^ $b->limbs[3])
856 );
857 return $return;
858 }
859
860 /**
861 * @param int $low
862 * @param int $high
863 * @return self
864 * @throws SodiumException
865 * @throws TypeError
866 */
867 public static function fromInts($low, $high)
868 {
869 ParagonIE_Sodium_Core32_Util::declareScalarType($low, 'int', 1);
870 ParagonIE_Sodium_Core32_Util::declareScalarType($high, 'int', 2);
871
872 $high = (int) $high;
873 $low = (int) $low;
874 return new ParagonIE_Sodium_Core32_Int64(
875 array(
876 (int) (($high >> 16) & 0xffff),
877 (int) ($high & 0xffff),
878 (int) (($low >> 16) & 0xffff),
879 (int) ($low & 0xffff)
880 )
881 );
882 }
883
884 /**
885 * @param int $low
886 * @return self
887 * @throws SodiumException
888 * @throws TypeError
889 */
890 public static function fromInt($low)
891 {
892 ParagonIE_Sodium_Core32_Util::declareScalarType($low, 'int', 1);
893 $low = (int) $low;
894
895 return new ParagonIE_Sodium_Core32_Int64(
896 array(
897 0,
898 0,
899 (int) (($low >> 16) & 0xffff),
900 (int) ($low & 0xffff)
901 )
902 );
903 }
904
905 /**
906 * @return int
907 */
908 public function toInt()
909 {
910 return (int) (
911 (($this->limbs[2] & 0xffff) << 16)
912 |
913 ($this->limbs[3] & 0xffff)
914 );
915 }
916
917 /**
918 * @param string $string
919 * @return self
920 * @throws SodiumException
921 * @throws TypeError
922 */
923 public static function fromString($string)
924 {
925 ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
926 $string = (string) $string;
927 if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 8) {
928 throw new RangeException(
929 'String must be 8 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
930 );
931 }
932 $return = new ParagonIE_Sodium_Core32_Int64();
933
934 $return->limbs[0] = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff) << 8);
935 $return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff);
936 $return->limbs[1] = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff) << 8);
937 $return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff);
938 $return->limbs[2] = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[4]) & 0xff) << 8);
939 $return->limbs[2] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[5]) & 0xff);
940 $return->limbs[3] = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[6]) & 0xff) << 8);
941 $return->limbs[3] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[7]) & 0xff);
942 return $return;
943 }
944
945 /**
946 * @param string $string
947 * @return self
948 * @throws SodiumException
949 * @throws TypeError
950 */
951 public static function fromReverseString($string)
952 {
953 ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
954 $string = (string) $string;
955 if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 8) {
956 throw new RangeException(
957 'String must be 8 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
958 );
959 }
960 $return = new ParagonIE_Sodium_Core32_Int64();
961
962 $return->limbs[0] = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[7]) & 0xff) << 8);
963 $return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[6]) & 0xff);
964 $return->limbs[1] = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[5]) & 0xff) << 8);
965 $return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[4]) & 0xff);
966 $return->limbs[2] = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff) << 8);
967 $return->limbs[2] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff);
968 $return->limbs[3] = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff) << 8);
969 $return->limbs[3] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff);
970 return $return;
971 }
972
973 /**
974 * @return array<int, int>
975 */
976 public function toArray()
977 {
978 return array(
979 (int) ((($this->limbs[0] & 0xffff) << 16) | ($this->limbs[1] & 0xffff)),
980 (int) ((($this->limbs[2] & 0xffff) << 16) | ($this->limbs[3] & 0xffff))
981 );
982 }
983
984 /**
985 * @return ParagonIE_Sodium_Core32_Int32
986 */
987 public function toInt32()
988 {
989 $return = new ParagonIE_Sodium_Core32_Int32();
990 $return->limbs[0] = (int) ($this->limbs[2]);
991 $return->limbs[1] = (int) ($this->limbs[3]);
992 $return->unsignedInt = $this->unsignedInt;
993 $return->overflow = (int) (ParagonIE_Sodium_Core32_Util::abs($this->limbs[1], 16) & 0xffff);
994 return $return;
995 }
996
997 /**
998 * @return ParagonIE_Sodium_Core32_Int64
999 */
1000 public function toInt64()
1001 {
1002 $return = new ParagonIE_Sodium_Core32_Int64();
1003 $return->limbs[0] = (int) ($this->limbs[0]);
1004 $return->limbs[1] = (int) ($this->limbs[1]);
1005 $return->limbs[2] = (int) ($this->limbs[2]);
1006 $return->limbs[3] = (int) ($this->limbs[3]);
1007 $return->unsignedInt = $this->unsignedInt;
1008 $return->overflow = ParagonIE_Sodium_Core32_Util::abs($this->overflow);
1009 return $return;
1010 }
1011
1012 /**
1013 * @param bool $bool
1014 * @return self
1015 */
1016 public function setUnsignedInt($bool = false)
1017 {
1018 $this->unsignedInt = !empty($bool);
1019 return $this;
1020 }
1021
1022 /**
1023 * @return string
1024 * @throws TypeError
1025 */
1026 public function toString()
1027 {
1028 return ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff) .
1029 ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
1030 ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .
1031 ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff) .
1032 ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[2] >> 8) & 0xff) .
1033 ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[2] & 0xff) .
1034 ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[3] >> 8) & 0xff) .
1035 ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[3] & 0xff);
1036 }
1037
1038 /**
1039 * @return string
1040 * @throws TypeError
1041 */
1042 public function toReverseString()
1043 {
1044 return ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[3] & 0xff) .
1045 ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[3] >> 8) & 0xff) .
1046 ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[2] & 0xff) .
1047 ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[2] >> 8) & 0xff) .
1048 ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff) .
1049 ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .
1050 ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .
1051 ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff);
1052 }
1053
1054 /**
1055 * @return string
1056 */
1057 public function __toString()
1058 {
1059 try {
1060 return $this->toString();
1061 } catch (TypeError $ex) {
1062 // PHP engine can't handle exceptions from __toString()
1063 return '';
1064 }
1065 }
1066}
1067