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