[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/sodium_compat/src/Core32/ -> Salsa20.php (source)

   1  <?php
   2  
   3  if (class_exists('ParagonIE_Sodium_Core32_Salsa20', false)) {
   4      return;
   5  }
   6  
   7  /**
   8   * Class ParagonIE_Sodium_Core32_Salsa20
   9   */
  10  abstract class ParagonIE_Sodium_Core32_Salsa20 extends ParagonIE_Sodium_Core32_Util
  11  {
  12      const ROUNDS = 20;
  13  
  14      /**
  15       * Calculate an salsa20 hash of a single block
  16       *
  17       * @internal You should not use this directly from another application
  18       *
  19       * @param string $in
  20       * @param string $k
  21       * @param string|null $c
  22       * @return string
  23       * @throws SodiumException
  24       * @throws TypeError
  25       */
  26      public static function core_salsa20($in, $k, $c = null)
  27      {
  28          /**
  29           * @var ParagonIE_Sodium_Core32_Int32 $x0
  30           * @var ParagonIE_Sodium_Core32_Int32 $x1
  31           * @var ParagonIE_Sodium_Core32_Int32 $x2
  32           * @var ParagonIE_Sodium_Core32_Int32 $x3
  33           * @var ParagonIE_Sodium_Core32_Int32 $x4
  34           * @var ParagonIE_Sodium_Core32_Int32 $x5
  35           * @var ParagonIE_Sodium_Core32_Int32 $x6
  36           * @var ParagonIE_Sodium_Core32_Int32 $x7
  37           * @var ParagonIE_Sodium_Core32_Int32 $x8
  38           * @var ParagonIE_Sodium_Core32_Int32 $x9
  39           * @var ParagonIE_Sodium_Core32_Int32 $x10
  40           * @var ParagonIE_Sodium_Core32_Int32 $x11
  41           * @var ParagonIE_Sodium_Core32_Int32 $x12
  42           * @var ParagonIE_Sodium_Core32_Int32 $x13
  43           * @var ParagonIE_Sodium_Core32_Int32 $x14
  44           * @var ParagonIE_Sodium_Core32_Int32 $x15
  45           * @var ParagonIE_Sodium_Core32_Int32 $j0
  46           * @var ParagonIE_Sodium_Core32_Int32 $j1
  47           * @var ParagonIE_Sodium_Core32_Int32 $j2
  48           * @var ParagonIE_Sodium_Core32_Int32 $j3
  49           * @var ParagonIE_Sodium_Core32_Int32 $j4
  50           * @var ParagonIE_Sodium_Core32_Int32 $j5
  51           * @var ParagonIE_Sodium_Core32_Int32 $j6
  52           * @var ParagonIE_Sodium_Core32_Int32 $j7
  53           * @var ParagonIE_Sodium_Core32_Int32 $j8
  54           * @var ParagonIE_Sodium_Core32_Int32 $j9
  55           * @var ParagonIE_Sodium_Core32_Int32 $j10
  56           * @var ParagonIE_Sodium_Core32_Int32 $j11
  57           * @var ParagonIE_Sodium_Core32_Int32 $j12
  58           * @var ParagonIE_Sodium_Core32_Int32 $j13
  59           * @var ParagonIE_Sodium_Core32_Int32 $j14
  60           * @var ParagonIE_Sodium_Core32_Int32 $j15
  61           */
  62          if (self::strlen($k) < 32) {
  63              throw new RangeException('Key must be 32 bytes long');
  64          }
  65          if ($c === null) {
  66              $x0  = new ParagonIE_Sodium_Core32_Int32(array(0x6170, 0x7865));
  67              $x5  = new ParagonIE_Sodium_Core32_Int32(array(0x3320, 0x646e));
  68              $x10 = new ParagonIE_Sodium_Core32_Int32(array(0x7962, 0x2d32));
  69              $x15 = new ParagonIE_Sodium_Core32_Int32(array(0x6b20, 0x6574));
  70          } else {
  71              $x0  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($c, 0, 4));
  72              $x5  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($c, 4, 4));
  73              $x10 = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($c, 8, 4));
  74              $x15 = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($c, 12, 4));
  75          }
  76          $x1  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($k, 0, 4));
  77          $x2  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($k, 4, 4));
  78          $x3  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($k, 8, 4));
  79          $x4  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($k, 12, 4));
  80          $x6  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($in, 0, 4));
  81          $x7  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($in, 4, 4));
  82          $x8  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($in, 8, 4));
  83          $x9  = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($in, 12, 4));
  84          $x11 = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($k, 16, 4));
  85          $x12 = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($k, 20, 4));
  86          $x13 = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($k, 24, 4));
  87          $x14 = ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($k, 28, 4));
  88  
  89          $j0  = clone $x0;
  90          $j1  = clone $x1;
  91          $j2  = clone $x2;
  92          $j3  = clone $x3;
  93          $j4  = clone $x4;
  94          $j5  = clone $x5;
  95          $j6  = clone $x6;
  96          $j7  = clone $x7;
  97          $j8  = clone $x8;
  98          $j9  = clone $x9;
  99          $j10  = clone $x10;
 100          $j11  = clone $x11;
 101          $j12  = clone $x12;
 102          $j13  = clone $x13;
 103          $j14  = clone $x14;
 104          $j15  = clone $x15;
 105  
 106          for ($i = self::ROUNDS; $i > 0; $i -= 2) {
 107              $x4  = $x4->xorInt32($x0->addInt32($x12)->rotateLeft(7));
 108              $x8  = $x8->xorInt32($x4->addInt32($x0)->rotateLeft(9));
 109              $x12 = $x12->xorInt32($x8->addInt32($x4)->rotateLeft(13));
 110              $x0  = $x0->xorInt32($x12->addInt32($x8)->rotateLeft(18));
 111  
 112              $x9  = $x9->xorInt32($x5->addInt32($x1)->rotateLeft(7));
 113              $x13 = $x13->xorInt32($x9->addInt32($x5)->rotateLeft(9));
 114              $x1  = $x1->xorInt32($x13->addInt32($x9)->rotateLeft(13));
 115              $x5  = $x5->xorInt32($x1->addInt32($x13)->rotateLeft(18));
 116  
 117              $x14 = $x14->xorInt32($x10->addInt32($x6)->rotateLeft(7));
 118              $x2  = $x2->xorInt32($x14->addInt32($x10)->rotateLeft(9));
 119              $x6  = $x6->xorInt32($x2->addInt32($x14)->rotateLeft(13));
 120              $x10 = $x10->xorInt32($x6->addInt32($x2)->rotateLeft(18));
 121  
 122              $x3  = $x3->xorInt32($x15->addInt32($x11)->rotateLeft(7));
 123              $x7  = $x7->xorInt32($x3->addInt32($x15)->rotateLeft(9));
 124              $x11 = $x11->xorInt32($x7->addInt32($x3)->rotateLeft(13));
 125              $x15 = $x15->xorInt32($x11->addInt32($x7)->rotateLeft(18));
 126  
 127              $x1  = $x1->xorInt32($x0->addInt32($x3)->rotateLeft(7));
 128              $x2  = $x2->xorInt32($x1->addInt32($x0)->rotateLeft(9));
 129              $x3  = $x3->xorInt32($x2->addInt32($x1)->rotateLeft(13));
 130              $x0  = $x0->xorInt32($x3->addInt32($x2)->rotateLeft(18));
 131  
 132              $x6  = $x6->xorInt32($x5->addInt32($x4)->rotateLeft(7));
 133              $x7  = $x7->xorInt32($x6->addInt32($x5)->rotateLeft(9));
 134              $x4  = $x4->xorInt32($x7->addInt32($x6)->rotateLeft(13));
 135              $x5  = $x5->xorInt32($x4->addInt32($x7)->rotateLeft(18));
 136  
 137              $x11 = $x11->xorInt32($x10->addInt32($x9)->rotateLeft(7));
 138              $x8  = $x8->xorInt32($x11->addInt32($x10)->rotateLeft(9));
 139              $x9  = $x9->xorInt32($x8->addInt32($x11)->rotateLeft(13));
 140              $x10 = $x10->xorInt32($x9->addInt32($x8)->rotateLeft(18));
 141  
 142              $x12 = $x12->xorInt32($x15->addInt32($x14)->rotateLeft(7));
 143              $x13 = $x13->xorInt32($x12->addInt32($x15)->rotateLeft(9));
 144              $x14 = $x14->xorInt32($x13->addInt32($x12)->rotateLeft(13));
 145              $x15 = $x15->xorInt32($x14->addInt32($x13)->rotateLeft(18));
 146          }
 147  
 148          $x0  = $x0->addInt32($j0);
 149          $x1  = $x1->addInt32($j1);
 150          $x2  = $x2->addInt32($j2);
 151          $x3  = $x3->addInt32($j3);
 152          $x4  = $x4->addInt32($j4);
 153          $x5  = $x5->addInt32($j5);
 154          $x6  = $x6->addInt32($j6);
 155          $x7  = $x7->addInt32($j7);
 156          $x8  = $x8->addInt32($j8);
 157          $x9  = $x9->addInt32($j9);
 158          $x10 = $x10->addInt32($j10);
 159          $x11 = $x11->addInt32($j11);
 160          $x12 = $x12->addInt32($j12);
 161          $x13 = $x13->addInt32($j13);
 162          $x14 = $x14->addInt32($j14);
 163          $x15 = $x15->addInt32($j15);
 164  
 165          return $x0->toReverseString() .
 166              $x1->toReverseString() .
 167              $x2->toReverseString() .
 168              $x3->toReverseString() .
 169              $x4->toReverseString() .
 170              $x5->toReverseString() .
 171              $x6->toReverseString() .
 172              $x7->toReverseString() .
 173              $x8->toReverseString() .
 174              $x9->toReverseString() .
 175              $x10->toReverseString() .
 176              $x11->toReverseString() .
 177              $x12->toReverseString() .
 178              $x13->toReverseString() .
 179              $x14->toReverseString() .
 180              $x15->toReverseString();
 181      }
 182  
 183      /**
 184       * @internal You should not use this directly from another application
 185       *
 186       * @param int $len
 187       * @param string $nonce
 188       * @param string $key
 189       * @return string
 190       * @throws SodiumException
 191       * @throws TypeError
 192       */
 193      public static function salsa20($len, $nonce, $key)
 194      {
 195          if (self::strlen($key) !== 32) {
 196              throw new RangeException('Key must be 32 bytes long');
 197          }
 198          $kcopy = '' . $key;
 199          $in = self::substr($nonce, 0, 8) . str_repeat("\0", 8);
 200          $c = '';
 201          while ($len >= 64) {
 202              $c .= self::core_salsa20($in, $kcopy, null);
 203              $u = 1;
 204              // Internal counter.
 205              for ($i = 8; $i < 16; ++$i) {
 206                  $u += self::chrToInt($in[$i]);
 207                  $in[$i] = self::intToChr($u & 0xff);
 208                  $u >>= 8;
 209              }
 210              $len -= 64;
 211          }
 212          if ($len > 0) {
 213              $c .= self::substr(
 214                  self::core_salsa20($in, $kcopy, null),
 215                  0,
 216                  $len
 217              );
 218          }
 219          try {
 220              ParagonIE_Sodium_Compat::memzero($kcopy);
 221          } catch (SodiumException $ex) {
 222              $kcopy = null;
 223          }
 224          return $c;
 225      }
 226  
 227      /**
 228       * @internal You should not use this directly from another application
 229       *
 230       * @param string $m
 231       * @param string $n
 232       * @param int $ic
 233       * @param string $k
 234       * @return string
 235       * @throws SodiumException
 236       * @throws TypeError
 237       */
 238      public static function salsa20_xor_ic($m, $n, $ic, $k)
 239      {
 240          $mlen = self::strlen($m);
 241          if ($mlen < 1) {
 242              return '';
 243          }
 244          $kcopy = self::substr($k, 0, 32);
 245          $in = self::substr($n, 0, 8);
 246          // Initialize the counter
 247          $in .= ParagonIE_Sodium_Core32_Util::store64_le($ic);
 248  
 249          $c = '';
 250          while ($mlen >= 64) {
 251              $block = self::core_salsa20($in, $kcopy, null);
 252              $c .= self::xorStrings(
 253                  self::substr($m, 0, 64),
 254                  self::substr($block, 0, 64)
 255              );
 256              $u = 1;
 257              for ($i = 8; $i < 16; ++$i) {
 258                  $u += self::chrToInt($in[$i]);
 259                  $in[$i] = self::intToChr($u & 0xff);
 260                  $u >>= 8;
 261              }
 262  
 263              $mlen -= 64;
 264              $m = self::substr($m, 64);
 265          }
 266  
 267          if ($mlen) {
 268              $block = self::core_salsa20($in, $kcopy, null);
 269              $c .= self::xorStrings(
 270                  self::substr($m, 0, $mlen),
 271                  self::substr($block, 0, $mlen)
 272              );
 273          }
 274          try {
 275              ParagonIE_Sodium_Compat::memzero($block);
 276              ParagonIE_Sodium_Compat::memzero($kcopy);
 277          } catch (SodiumException $ex) {
 278              $block = null;
 279              $kcopy = null;
 280          }
 281  
 282          return $c;
 283      }
 284  
 285      /**
 286       * @internal You should not use this directly from another application
 287       *
 288       * @param string $message
 289       * @param string $nonce
 290       * @param string $key
 291       * @return string
 292       * @throws SodiumException
 293       * @throws TypeError
 294       */
 295      public static function salsa20_xor($message, $nonce, $key)
 296      {
 297          return self::xorStrings(
 298              $message,
 299              self::salsa20(
 300                  self::strlen($message),
 301                  $nonce,
 302                  $key
 303              )
 304          );
 305      }
 306  }


Generated: Fri Jul 19 01:00:04 2019 Cross-referenced by PHPXref 0.7.1