[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

title

Body

[close]

/wp-includes/sodium_compat/src/Core/ -> BLAKE2b.php (source)

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


Generated: Fri Oct 25 08:20:01 2019 Cross-referenced by PHPXref 0.7