1<?php
2
3if (class_exists('ParagonIE_Sodium_Core_BLAKE2b', false)) {
4 return;
5}
6
7/**
8 * Class ParagonIE_Sodium_Core_BLAKE2b
9 *
10 * Based on the work of Devi Mandiri in devi/salt.
11 */
12abstract class ParagonIE_Sodium_Core32_BLAKE2b extends ParagonIE_Sodium_Core_Util
13{
14 /**
15 * @var SplFixedArray
16 */
17 public static $iv;
18
19 /**
20 * @var array<int, array<int, int>>
21 */
22 public static $sigma = array(
23 array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15),
24 array( 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3),
25 array( 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4),
26 array( 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8),
27 array( 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13),
28 array( 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9),
29 array( 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11),
30 array( 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10),
31 array( 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5),
32 array( 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0),
33 array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15),
34 array( 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3)
35 );
36
37 const BLOCKBYTES = 128;
38 const OUTBYTES = 64;
39 const KEYBYTES = 64;
40
41 /**
42 * Turn two 32-bit integers into a fixed array representing a 64-bit integer.
43 *
44 * @internal You should not use this directly from another application
45 *
46 * @param int $high
47 * @param int $low
48 * @return ParagonIE_Sodium_Core32_Int64
49 * @throws SodiumException
50 * @throws TypeError
51 */
52 public static function new64($high, $low)
53 {
54 return ParagonIE_Sodium_Core32_Int64::fromInts($low, $high);
55 }
56
57 /**
58 * Convert an arbitrary number into an SplFixedArray of two 32-bit integers
59 * that represents a 64-bit integer.
60 *
61 * @internal You should not use this directly from another application
62 *
63 * @param int $num
64 * @return ParagonIE_Sodium_Core32_Int64
65 * @throws SodiumException
66 * @throws TypeError
67 */
68 protected static function to64($num)
69 {
70 list($hi, $lo) = self::numericTo64BitInteger($num);
71 return self::new64($hi, $lo);
72 }
73
74 /**
75 * Adds two 64-bit integers together, returning their sum as a SplFixedArray
76 * containing two 32-bit integers (representing a 64-bit integer).
77 *
78 * @internal You should not use this directly from another application
79 *
80 * @param ParagonIE_Sodium_Core32_Int64 $x
81 * @param ParagonIE_Sodium_Core32_Int64 $y
82 * @return ParagonIE_Sodium_Core32_Int64
83 */
84 protected static function add64($x, $y)
85 {
86 return $x->addInt64($y);
87 }
88
89 /**
90 * @internal You should not use this directly from another application
91 *
92 * @param ParagonIE_Sodium_Core32_Int64 $x
93 * @param ParagonIE_Sodium_Core32_Int64 $y
94 * @param ParagonIE_Sodium_Core32_Int64 $z
95 * @return ParagonIE_Sodium_Core32_Int64
96 */
97 public static function add364($x, $y, $z)
98 {
99 return $x->addInt64($y)->addInt64($z);
100 }
101
102 /**
103 * @internal You should not use this directly from another application
104 *
105 * @param ParagonIE_Sodium_Core32_Int64 $x
106 * @param ParagonIE_Sodium_Core32_Int64 $y
107 * @return ParagonIE_Sodium_Core32_Int64
108 * @throws TypeError
109 */
110 public static function xor64(ParagonIE_Sodium_Core32_Int64 $x, ParagonIE_Sodium_Core32_Int64 $y)
111 {
112 return $x->xorInt64($y);
113 }
114
115 /**
116 * @internal You should not use this directly from another application
117 *
118 * @param ParagonIE_Sodium_Core32_Int64 $x
119 * @param int $c
120 * @return ParagonIE_Sodium_Core32_Int64
121 * @throws SodiumException
122 * @throws TypeError
123 */
124 public static function rotr64(ParagonIE_Sodium_Core32_Int64 $x, $c)
125 {
126 return $x->rotateRight($c);
127 }
128
129 /**
130 * @internal You should not use this directly from another application
131 *
132 * @param SplFixedArray $x
133 * @param int $i
134 * @return ParagonIE_Sodium_Core32_Int64
135 * @throws SodiumException
136 * @throws TypeError
137 */
138 public static function load64($x, $i)
139 {
140 /** @var int $l */
141 $l = (int) ($x[$i])
142 | ((int) ($x[$i+1]) << 8)
143 | ((int) ($x[$i+2]) << 16)
144 | ((int) ($x[$i+3]) << 24);
145 /** @var int $h */
146 $h = (int) ($x[$i+4])
147 | ((int) ($x[$i+5]) << 8)
148 | ((int) ($x[$i+6]) << 16)
149 | ((int) ($x[$i+7]) << 24);
150 return self::new64($h, $l);
151 }
152
153 /**
154 * @internal You should not use this directly from another application
155 *
156 * @param SplFixedArray $x
157 * @param int $i
158 * @param ParagonIE_Sodium_Core32_Int64 $u
159 * @return void
160 * @throws TypeError
161 * @psalm-suppress MixedArgument
162 * @psalm-suppress MixedAssignment
163 * @psalm-suppress MixedArrayAccess
164 * @psalm-suppress MixedArrayAssignment
165 * @psalm-suppress MixedArrayOffset
166 */
167 public static function store64(SplFixedArray $x, $i, ParagonIE_Sodium_Core32_Int64 $u)
168 {
169 $v = clone $u;
170 $maxLength = $x->getSize() - 1;
171 for ($j = 0; $j < 8; ++$j) {
172 $k = 3 - ($j >> 1);
173 $x[$i] = $v->limbs[$k] & 0xff;
174 if (++$i > $maxLength) {
175 return;
176 }
177 $v->limbs[$k] >>= 8;
178 }
179 }
180
181 /**
182 * This just sets the $iv static variable.
183 *
184 * @internal You should not use this directly from another application
185 *
186 * @return void
187 * @throws SodiumException
188 * @throws TypeError
189 */
190 public static function pseudoConstructor()
191 {
192 static $called = false;
193 if ($called) {
194 return;
195 }
196 self::$iv = new SplFixedArray(8);
197 self::$iv[0] = self::new64(0x6a09e667, 0xf3bcc908);
198 self::$iv[1] = self::new64(0xbb67ae85, 0x84caa73b);
199 self::$iv[2] = self::new64(0x3c6ef372, 0xfe94f82b);
200 self::$iv[3] = self::new64(0xa54ff53a, 0x5f1d36f1);
201 self::$iv[4] = self::new64(0x510e527f, 0xade682d1);
202 self::$iv[5] = self::new64(0x9b05688c, 0x2b3e6c1f);
203 self::$iv[6] = self::new64(0x1f83d9ab, 0xfb41bd6b);
204 self::$iv[7] = self::new64(0x5be0cd19, 0x137e2179);
205
206 $called = true;
207 }
208
209 /**
210 * Returns a fresh BLAKE2 context.
211 *
212 * @internal You should not use this directly from another application
213 *
214 * @return SplFixedArray
215 * @throws TypeError
216 * @psalm-suppress MixedArgument
217 * @psalm-suppress MixedAssignment
218 * @psalm-suppress MixedArrayAccess
219 * @psalm-suppress MixedArrayAssignment
220 * @psalm-suppress MixedArrayOffset
221 * @throws SodiumException
222 * @throws TypeError
223 */
224 protected static function context()
225 {
226 $ctx = new SplFixedArray(6);
227 $ctx[0] = new SplFixedArray(8); // h
228 $ctx[1] = new SplFixedArray(2); // t
229 $ctx[2] = new SplFixedArray(2); // f
230 $ctx[3] = new SplFixedArray(256); // buf
231 $ctx[4] = 0; // buflen
232 $ctx[5] = 0; // last_node (uint8_t)
233
234 for ($i = 8; $i--;) {
235 $ctx[0][$i] = self::$iv[$i];
236 }
237 for ($i = 256; $i--;) {
238 $ctx[3][$i] = 0;
239 }
240
241 $zero = self::new64(0, 0);
242 $ctx[1][0] = $zero;
243 $ctx[1][1] = $zero;
244 $ctx[2][0] = $zero;
245 $ctx[2][1] = $zero;
246
247 return $ctx;
248 }
249
250 /**
251 * @internal You should not use this directly from another application
252 *
253 * @param SplFixedArray $ctx
254 * @param SplFixedArray $buf
255 * @return void
256 * @throws SodiumException
257 * @throws TypeError
258 * @psalm-suppress MixedArgument
259 * @psalm-suppress MixedArrayAccess
260 * @psalm-suppress MixedArrayAssignment
261 * @psalm-suppress MixedAssignment
262 */
263 protected static function compress(SplFixedArray $ctx, SplFixedArray $buf)
264 {
265 $m = new SplFixedArray(16);
266 $v = new SplFixedArray(16);
267
268 for ($i = 16; $i--;) {
269 $m[$i] = self::load64($buf, $i << 3);
270 }
271
272 for ($i = 8; $i--;) {
273 $v[$i] = $ctx[0][$i];
274 }
275
276 $v[ 8] = self::$iv[0];
277 $v[ 9] = self::$iv[1];
278 $v[10] = self::$iv[2];
279 $v[11] = self::$iv[3];
280
281 $v[12] = self::xor64($ctx[1][0], self::$iv[4]);
282 $v[13] = self::xor64($ctx[1][1], self::$iv[5]);
283 $v[14] = self::xor64($ctx[2][0], self::$iv[6]);
284 $v[15] = self::xor64($ctx[2][1], self::$iv[7]);
285
286 for ($r = 0; $r < 12; ++$r) {
287 $v = self::G($r, 0, 0, 4, 8, 12, $v, $m);
288 $v = self::G($r, 1, 1, 5, 9, 13, $v, $m);
289 $v = self::G($r, 2, 2, 6, 10, 14, $v, $m);
290 $v = self::G($r, 3, 3, 7, 11, 15, $v, $m);
291 $v = self::G($r, 4, 0, 5, 10, 15, $v, $m);
292 $v = self::G($r, 5, 1, 6, 11, 12, $v, $m);
293 $v = self::G($r, 6, 2, 7, 8, 13, $v, $m);
294 $v = self::G($r, 7, 3, 4, 9, 14, $v, $m);
295 }
296
297 for ($i = 8; $i--;) {
298 $ctx[0][$i] = self::xor64(
299 $ctx[0][$i], self::xor64($v[$i], $v[$i+8])
300 );
301 }
302 }
303
304 /**
305 * @internal You should not use this directly from another application
306 *
307 * @param int $r
308 * @param int $i
309 * @param int $a
310 * @param int $b
311 * @param int $c
312 * @param int $d
313 * @param SplFixedArray $v
314 * @param SplFixedArray $m
315 * @return SplFixedArray
316 * @throws SodiumException
317 * @throws TypeError
318 * @psalm-suppress MixedArgument
319 * @psalm-suppress MixedArrayOffset
320 */
321 public static function G($r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m)
322 {
323 $v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][$i << 1]]);
324 $v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 32);
325 $v[$c] = self::add64($v[$c], $v[$d]);
326 $v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 24);
327 $v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][($i << 1) + 1]]);
328 $v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 16);
329 $v[$c] = self::add64($v[$c], $v[$d]);
330 $v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 63);
331 return $v;
332 }
333
334 /**
335 * @internal You should not use this directly from another application
336 *
337 * @param SplFixedArray $ctx
338 * @param int $inc
339 * @return void
340 * @throws SodiumException
341 * @throws TypeError
342 * @psalm-suppress MixedArgument
343 * @psalm-suppress MixedArrayAccess
344 * @psalm-suppress MixedArrayAssignment
345 */
346 public static function increment_counter($ctx, $inc)
347 {
348 if ($inc < 0) {
349 throw new SodiumException('Increasing by a negative number makes no sense.');
350 }
351 $t = self::to64($inc);
352 # S->t is $ctx[1] in our implementation
353
354 # S->t[0] = ( uint64_t )( t >> 0 );
355 $ctx[1][0] = self::add64($ctx[1][0], $t);
356
357 # S->t[1] += ( S->t[0] < inc );
358 if (!($ctx[1][0] instanceof ParagonIE_Sodium_Core32_Int64)) {
359 throw new TypeError('Not an int64');
360 }
361 /** @var ParagonIE_Sodium_Core32_Int64 $c*/
362 $c = $ctx[1][0];
363 if ($c->isLessThanInt($inc)) {
364 $ctx[1][1] = self::add64($ctx[1][1], self::to64(1));
365 }
366 }
367
368 /**
369 * @internal You should not use this directly from another application
370 *
371 * @param SplFixedArray $ctx
372 * @param SplFixedArray $p
373 * @param int $plen
374 * @return void
375 * @throws SodiumException
376 * @throws TypeError
377 * @psalm-suppress MixedArgument
378 * @psalm-suppress MixedAssignment
379 * @psalm-suppress MixedArrayAccess
380 * @psalm-suppress MixedArrayAssignment
381 * @psalm-suppress MixedArrayOffset
382 * @psalm-suppress MixedMethodCall
383 * @psalm-suppress MixedOperand
384 */
385 public static function update(SplFixedArray $ctx, SplFixedArray $p, $plen)
386 {
387 self::pseudoConstructor();
388
389 $offset = 0;
390 while ($plen > 0) {
391 $left = $ctx[4];
392 $fill = 256 - $left;
393
394 if ($plen > $fill) {
395 # memcpy( S->buf + left, in, fill ); /* Fill buffer */
396 for ($i = $fill; $i--;) {
397 $ctx[3][$i + $left] = $p[$i + $offset];
398 }
399
400 # S->buflen += fill;
401 $ctx[4] += $fill;
402
403 # blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
404 self::increment_counter($ctx, 128);
405
406 # blake2b_compress( S, S->buf ); /* Compress */
407 self::compress($ctx, $ctx[3]);
408
409 # memcpy( S->buf, S->buf + BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES ); /* Shift buffer left */
410 for ($i = 128; $i--;) {
411 $ctx[3][$i] = $ctx[3][$i + 128];
412 }
413
414 # S->buflen -= BLAKE2B_BLOCKBYTES;
415 $ctx[4] -= 128;
416
417 # in += fill;
418 $offset += $fill;
419
420 # inlen -= fill;
421 $plen -= $fill;
422 } else {
423 for ($i = $plen; $i--;) {
424 $ctx[3][$i + $left] = $p[$i + $offset];
425 }
426 $ctx[4] += $plen;
427 $offset += $plen;
428 $plen -= $plen;
429 }
430 }
431 }
432
433 /**
434 * @internal You should not use this directly from another application
435 *
436 * @param SplFixedArray $ctx
437 * @param SplFixedArray $out
438 * @return SplFixedArray
439 * @throws SodiumException
440 * @throws TypeError
441 * @psalm-suppress MixedArgument
442 * @psalm-suppress MixedAssignment
443 * @psalm-suppress MixedArrayAccess
444 * @psalm-suppress MixedArrayAssignment
445 * @psalm-suppress MixedArrayOffset
446 * @psalm-suppress MixedMethodCall
447 * @psalm-suppress MixedOperand
448 */
449 public static function finish(SplFixedArray $ctx, SplFixedArray $out)
450 {
451 self::pseudoConstructor();
452 if ($ctx[4] > 128) {
453 self::increment_counter($ctx, 128);
454 self::compress($ctx, $ctx[3]);
455 $ctx[4] -= 128;
456 if ($ctx[4] > 128) {
457 throw new SodiumException('Failed to assert that buflen <= 128 bytes');
458 }
459 for ($i = $ctx[4]; $i--;) {
460 $ctx[3][$i] = $ctx[3][$i + 128];
461 }
462 }
463
464 self::increment_counter($ctx, $ctx[4]);
465 $ctx[2][0] = self::new64(0xffffffff, 0xffffffff);
466
467 for ($i = 256 - $ctx[4]; $i--;) {
468 /** @var int $i */
469 $ctx[3][$i + $ctx[4]] = 0;
470 }
471
472 self::compress($ctx, $ctx[3]);
473
474 $i = (int) (($out->getSize() - 1) / 8);
475 for (; $i >= 0; --$i) {
476 self::store64($out, $i << 3, $ctx[0][$i]);
477 }
478 return $out;
479 }
480
481 /**
482 * @internal You should not use this directly from another application
483 *
484 * @param SplFixedArray|null $key
485 * @param int $outlen
486 * @param SplFixedArray|null $salt
487 * @param SplFixedArray|null $personal
488 * @return SplFixedArray
489 * @throws SodiumException
490 * @throws TypeError
491 * @psalm-suppress MixedArgument
492 * @psalm-suppress MixedAssignment
493 * @psalm-suppress MixedArrayAccess
494 * @psalm-suppress MixedArrayAssignment
495 * @psalm-suppress MixedMethodCall
496 */
497 public static function init(
498 $key = null,
499 $outlen = 64,
500 $salt = null,
501 $personal = null
502 ) {
503 self::pseudoConstructor();
504 $klen = 0;
505
506 if ($key !== null) {
507 if (count($key) > 64) {
508 throw new SodiumException('Invalid key size');
509 }
510 $klen = count($key);
511 }
512
513 if ($outlen > 64) {
514 throw new SodiumException('Invalid output size');
515 }
516
517 $ctx = self::context();
518
519 $p = new SplFixedArray(64);
520 // Zero our param buffer...
521 for ($i = 64; --$i;) {
522 $p[$i] = 0;
523 }
524
525 $p[0] = $outlen; // digest_length
526 $p[1] = $klen; // key_length
527 $p[2] = 1; // fanout
528 $p[3] = 1; // depth
529
530 if ($salt instanceof SplFixedArray) {
531 // salt: [32] through [47]
532 for ($i = 0; $i < 16; ++$i) {
533 $p[32 + $i] = (int) $salt[$i];
534 }
535 }
536 if ($personal instanceof SplFixedArray) {
537 // personal: [48] through [63]
538 for ($i = 0; $i < 16; ++$i) {
539 $p[48 + $i] = (int) $personal[$i];
540 }
541 }
542
543 $ctx[0][0] = self::xor64(
544 $ctx[0][0],
545 self::load64($p, 0)
546 );
547
548 if ($salt instanceof SplFixedArray || $personal instanceof SplFixedArray) {
549 // We need to do what blake2b_init_param() does:
550 for ($i = 1; $i < 8; ++$i) {
551 $ctx[0][$i] = self::xor64(
552 $ctx[0][$i],
553 self::load64($p, $i << 3)
554 );
555 }
556 }
557
558 if ($klen > 0 && $key instanceof SplFixedArray) {
559 $block = new SplFixedArray(128);
560 for ($i = 128; $i--;) {
561 $block[$i] = 0;
562 }
563 for ($i = $klen; $i--;) {
564 $block[$i] = $key[$i];
565 }
566 self::update($ctx, $block, 128);
567 $ctx[4] = 128;
568 }
569
570 return $ctx;
571 }
572
573 /**
574 * Convert a string into an SplFixedArray of integers
575 *
576 * @internal You should not use this directly from another application
577 *
578 * @param string $str
579 * @return SplFixedArray
580 * @psalm-suppress MixedArgumentTypeCoercion
581 */
582 public static function stringToSplFixedArray($str = '')
583 {
584 $values = unpack('C*', $str);
585 return SplFixedArray::fromArray(array_values($values));
586 }
587
588 /**
589 * Convert an SplFixedArray of integers into a string
590 *
591 * @internal You should not use this directly from another application
592 *
593 * @param SplFixedArray $a
594 * @return string
595 */
596 public static function SplFixedArrayToString(SplFixedArray $a)
597 {
598 /**
599 * @var array<int, string|int>
600 */
601 $arr = $a->toArray();
602 $c = $a->count();
603 array_unshift($arr, str_repeat('C', $c));
604 return (string) (call_user_func_array('pack', $arr));
605 }
606
607 /**
608 * @internal You should not use this directly from another application
609 *
610 * @param SplFixedArray $ctx
611 * @return string
612 * @throws TypeError
613 * @psalm-suppress MixedArgument
614 * @psalm-suppress MixedArrayAccess
615 * @psalm-suppress MixedArrayAssignment
616 * @psalm-suppress MixedMethodCall
617 */
618 public static function contextToString(SplFixedArray $ctx)
619 {
620 $str = '';
621 /** @var array<int, ParagonIE_Sodium_Core32_Int64> $ctxA */
622 $ctxA = $ctx[0]->toArray();
623
624 # uint64_t h[8];
625 for ($i = 0; $i < 8; ++$i) {
626 if (!($ctxA[$i] instanceof ParagonIE_Sodium_Core32_Int64)) {
627 throw new TypeError('Not an instance of Int64');
628 }
629 /** @var ParagonIE_Sodium_Core32_Int64 $ctxAi */
630 $ctxAi = $ctxA[$i];
631 $str .= $ctxAi->toReverseString();
632 }
633
634 # uint64_t t[2];
635 # uint64_t f[2];
636 for ($i = 1; $i < 3; ++$i) {
637 /** @var array<int, ParagonIE_Sodium_Core32_Int64> $ctxA */
638 $ctxA = $ctx[$i]->toArray();
639 /** @var ParagonIE_Sodium_Core32_Int64 $ctxA1 */
640 $ctxA1 = $ctxA[0];
641 /** @var ParagonIE_Sodium_Core32_Int64 $ctxA2 */
642 $ctxA2 = $ctxA[1];
643
644 $str .= $ctxA1->toReverseString();
645 $str .= $ctxA2->toReverseString();
646 }
647
648 # uint8_t buf[2 * 128];
649 $str .= self::SplFixedArrayToString($ctx[3]);
650
651 /** @var int $ctx4 */
652 $ctx4 = $ctx[4];
653
654 # size_t buflen;
655 $str .= implode('', array(
656 self::intToChr($ctx4 & 0xff),
657 self::intToChr(($ctx4 >> 8) & 0xff),
658 self::intToChr(($ctx4 >> 16) & 0xff),
659 self::intToChr(($ctx4 >> 24) & 0xff),
660 "\x00\x00\x00\x00"
661 /*
662 self::intToChr(($ctx4 >> 32) & 0xff),
663 self::intToChr(($ctx4 >> 40) & 0xff),
664 self::intToChr(($ctx4 >> 48) & 0xff),
665 self::intToChr(($ctx4 >> 56) & 0xff)
666 */
667 ));
668 # uint8_t last_node;
669 return $str . self::intToChr($ctx[5]) . str_repeat("\x00", 23);
670 }
671
672 /**
673 * Creates an SplFixedArray containing other SplFixedArray elements, from
674 * a string (compatible with \Sodium\crypto_generichash_{init, update, final})
675 *
676 * @internal You should not use this directly from another application
677 *
678 * @param string $string
679 * @return SplFixedArray
680 * @throws SodiumException
681 * @throws TypeError
682 * @psalm-suppress MixedArrayAccess
683 * @psalm-suppress MixedArrayAssignment
684 */
685 public static function stringToContext($string)
686 {
687 $ctx = self::context();
688
689 # uint64_t h[8];
690 for ($i = 0; $i < 8; ++$i) {
691 $ctx[0][$i] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
692 self::substr($string, (($i << 3) + 0), 8)
693 );
694 }
695
696 # uint64_t t[2];
697 # uint64_t f[2];
698 for ($i = 1; $i < 3; ++$i) {
699 $ctx[$i][1] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
700 self::substr($string, 72 + (($i - 1) << 4), 8)
701 );
702 $ctx[$i][0] = ParagonIE_Sodium_Core32_Int64::fromReverseString(
703 self::substr($string, 64 + (($i - 1) << 4), 8)
704 );
705 }
706
707 # uint8_t buf[2 * 128];
708 $ctx[3] = self::stringToSplFixedArray(self::substr($string, 96, 256));
709
710 # uint8_t buf[2 * 128];
711 $int = 0;
712 for ($i = 0; $i < 8; ++$i) {
713 $int |= self::chrToInt($string[352 + $i]) << ($i << 3);
714 }
715 $ctx[4] = $int;
716
717 return $ctx;
718 }
719}
720