[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  if (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   */
  12  abstract 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  }