class ParagonIE_Sodium_Core32_ChaCha20 in Automatic Updates 8

Same name and namespace in other branches

7 vendor/paragonie/sodium_compat/src/Core32/ChaCha20.php \ParagonIE_Sodium_Core32_ChaCha20

Class ParagonIE_Sodium_Core32_ChaCha20

Hierarchy

class \ParagonIE_Sodium_Core_Util
- class \ParagonIE_Sodium_Core32_Util
  - class \ParagonIE_Sodium_Core32_ChaCha20

Expanded class hierarchy of ParagonIE_Sodium_Core32_ChaCha20

1 string reference to 'ParagonIE_Sodium_Core32_ChaCha20'

ChaCha20.php in vendor/paragonie/sodium_compat/src/Core32/ChaCha20.php

File

vendor/paragonie/sodium_compat/src/Core32/ChaCha20.php, line 10

View source

class ParagonIE_Sodium_Core32_ChaCha20 extends ParagonIE_Sodium_Core32_Util {

  /**
   * The ChaCha20 quarter round function. Works on four 32-bit integers.
   *
   * @internal You should not use this directly from another application
   *
   * @param ParagonIE_Sodium_Core32_Int32 $a
   * @param ParagonIE_Sodium_Core32_Int32 $b
   * @param ParagonIE_Sodium_Core32_Int32 $c
   * @param ParagonIE_Sodium_Core32_Int32 $d
   * @return array<int, ParagonIE_Sodium_Core32_Int32>
   * @throws SodiumException
   * @throws TypeError
   */
  protected static function quarterRound(ParagonIE_Sodium_Core32_Int32 $a, ParagonIE_Sodium_Core32_Int32 $b, ParagonIE_Sodium_Core32_Int32 $c, ParagonIE_Sodium_Core32_Int32 $d) {

    /** @var ParagonIE_Sodium_Core32_Int32 $a */

    /** @var ParagonIE_Sodium_Core32_Int32 $b */

    /** @var ParagonIE_Sodium_Core32_Int32 $c */

    /** @var ParagonIE_Sodium_Core32_Int32 $d */

    # a = PLUS(a,b); d = ROTATE(XOR(d,a),16);
    $a = $a
      ->addInt32($b);
    $d = $d
      ->xorInt32($a)
      ->rotateLeft(16);

    # c = PLUS(c,d); b = ROTATE(XOR(b,c),12);
    $c = $c
      ->addInt32($d);
    $b = $b
      ->xorInt32($c)
      ->rotateLeft(12);

    # a = PLUS(a,b); d = ROTATE(XOR(d,a), 8);
    $a = $a
      ->addInt32($b);
    $d = $d
      ->xorInt32($a)
      ->rotateLeft(8);

    # c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
    $c = $c
      ->addInt32($d);
    $b = $b
      ->xorInt32($c)
      ->rotateLeft(7);
    return array(
      $a,
      $b,
      $c,
      $d,
    );
  }

  /**
   * @internal You should not use this directly from another application
   *
   * @param ParagonIE_Sodium_Core32_ChaCha20_Ctx $ctx
   * @param string $message
   *
   * @return string
   * @throws SodiumException
   * @throws TypeError
   */
  public static function encryptBytes(ParagonIE_Sodium_Core32_ChaCha20_Ctx $ctx, $message = '') {
    $bytes = self::strlen($message);

    /** @var ParagonIE_Sodium_Core32_Int32 $x0 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x1 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x2 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x3 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x4 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x5 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x6 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x7 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x8 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x9 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x10 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x11 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x12 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x13 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x14 */

    /** @var ParagonIE_Sodium_Core32_Int32 $x15 */

    /*
    j0 = ctx->input[0];
    j1 = ctx->input[1];
    j2 = ctx->input[2];
    j3 = ctx->input[3];
    j4 = ctx->input[4];
    j5 = ctx->input[5];
    j6 = ctx->input[6];
    j7 = ctx->input[7];
    j8 = ctx->input[8];
    j9 = ctx->input[9];
    j10 = ctx->input[10];
    j11 = ctx->input[11];
    j12 = ctx->input[12];
    j13 = ctx->input[13];
    j14 = ctx->input[14];
    j15 = ctx->input[15];
    */

    /** @var ParagonIE_Sodium_Core32_Int32 $j0 */
    $j0 = $ctx[0];

    /** @var ParagonIE_Sodium_Core32_Int32 $j1 */
    $j1 = $ctx[1];

    /** @var ParagonIE_Sodium_Core32_Int32 $j2 */
    $j2 = $ctx[2];

    /** @var ParagonIE_Sodium_Core32_Int32 $j3 */
    $j3 = $ctx[3];

    /** @var ParagonIE_Sodium_Core32_Int32 $j4 */
    $j4 = $ctx[4];

    /** @var ParagonIE_Sodium_Core32_Int32 $j5 */
    $j5 = $ctx[5];

    /** @var ParagonIE_Sodium_Core32_Int32 $j6 */
    $j6 = $ctx[6];

    /** @var ParagonIE_Sodium_Core32_Int32 $j7 */
    $j7 = $ctx[7];

    /** @var ParagonIE_Sodium_Core32_Int32 $j8 */
    $j8 = $ctx[8];

    /** @var ParagonIE_Sodium_Core32_Int32 $j9 */
    $j9 = $ctx[9];

    /** @var ParagonIE_Sodium_Core32_Int32 $j10 */
    $j10 = $ctx[10];

    /** @var ParagonIE_Sodium_Core32_Int32 $j11 */
    $j11 = $ctx[11];

    /** @var ParagonIE_Sodium_Core32_Int32 $j12 */
    $j12 = $ctx[12];

    /** @var ParagonIE_Sodium_Core32_Int32 $j13 */
    $j13 = $ctx[13];

    /** @var ParagonIE_Sodium_Core32_Int32 $j14 */
    $j14 = $ctx[14];

    /** @var ParagonIE_Sodium_Core32_Int32 $j15 */
    $j15 = $ctx[15];
    $c = '';
    for (;;) {
      if ($bytes < 64) {
        $message .= str_repeat("\0", 64 - $bytes);
      }
      $x0 = clone $j0;
      $x1 = clone $j1;
      $x2 = clone $j2;
      $x3 = clone $j3;
      $x4 = clone $j4;
      $x5 = clone $j5;
      $x6 = clone $j6;
      $x7 = clone $j7;
      $x8 = clone $j8;
      $x9 = clone $j9;
      $x10 = clone $j10;
      $x11 = clone $j11;
      $x12 = clone $j12;
      $x13 = clone $j13;
      $x14 = clone $j14;
      $x15 = clone $j15;

      # for (i = 20; i > 0; i -= 2) {
      for ($i = 20; $i > 0; $i -= 2) {

        # QUARTERROUND( x0,  x4,  x8,  x12)
        list($x0, $x4, $x8, $x12) = self::quarterRound($x0, $x4, $x8, $x12);

        # QUARTERROUND( x1,  x5,  x9,  x13)
        list($x1, $x5, $x9, $x13) = self::quarterRound($x1, $x5, $x9, $x13);

        # QUARTERROUND( x2,  x6,  x10,  x14)
        list($x2, $x6, $x10, $x14) = self::quarterRound($x2, $x6, $x10, $x14);

        # QUARTERROUND( x3,  x7,  x11,  x15)
        list($x3, $x7, $x11, $x15) = self::quarterRound($x3, $x7, $x11, $x15);

        # QUARTERROUND( x0,  x5,  x10,  x15)
        list($x0, $x5, $x10, $x15) = self::quarterRound($x0, $x5, $x10, $x15);

        # QUARTERROUND( x1,  x6,  x11,  x12)
        list($x1, $x6, $x11, $x12) = self::quarterRound($x1, $x6, $x11, $x12);

        # QUARTERROUND( x2,  x7,  x8,  x13)
        list($x2, $x7, $x8, $x13) = self::quarterRound($x2, $x7, $x8, $x13);

        # QUARTERROUND( x3,  x4,  x9,  x14)
        list($x3, $x4, $x9, $x14) = self::quarterRound($x3, $x4, $x9, $x14);
      }

      /*
      x0 = PLUS(x0, j0);
      x1 = PLUS(x1, j1);
      x2 = PLUS(x2, j2);
      x3 = PLUS(x3, j3);
      x4 = PLUS(x4, j4);
      x5 = PLUS(x5, j5);
      x6 = PLUS(x6, j6);
      x7 = PLUS(x7, j7);
      x8 = PLUS(x8, j8);
      x9 = PLUS(x9, j9);
      x10 = PLUS(x10, j10);
      x11 = PLUS(x11, j11);
      x12 = PLUS(x12, j12);
      x13 = PLUS(x13, j13);
      x14 = PLUS(x14, j14);
      x15 = PLUS(x15, j15);
      */
      $x0 = $x0
        ->addInt32($j0);
      $x1 = $x1
        ->addInt32($j1);
      $x2 = $x2
        ->addInt32($j2);
      $x3 = $x3
        ->addInt32($j3);
      $x4 = $x4
        ->addInt32($j4);
      $x5 = $x5
        ->addInt32($j5);
      $x6 = $x6
        ->addInt32($j6);
      $x7 = $x7
        ->addInt32($j7);
      $x8 = $x8
        ->addInt32($j8);
      $x9 = $x9
        ->addInt32($j9);
      $x10 = $x10
        ->addInt32($j10);
      $x11 = $x11
        ->addInt32($j11);
      $x12 = $x12
        ->addInt32($j12);
      $x13 = $x13
        ->addInt32($j13);
      $x14 = $x14
        ->addInt32($j14);
      $x15 = $x15
        ->addInt32($j15);

      /*
      x0 = XOR(x0, LOAD32_LE(m + 0));
      x1 = XOR(x1, LOAD32_LE(m + 4));
      x2 = XOR(x2, LOAD32_LE(m + 8));
      x3 = XOR(x3, LOAD32_LE(m + 12));
      x4 = XOR(x4, LOAD32_LE(m + 16));
      x5 = XOR(x5, LOAD32_LE(m + 20));
      x6 = XOR(x6, LOAD32_LE(m + 24));
      x7 = XOR(x7, LOAD32_LE(m + 28));
      x8 = XOR(x8, LOAD32_LE(m + 32));
      x9 = XOR(x9, LOAD32_LE(m + 36));
      x10 = XOR(x10, LOAD32_LE(m + 40));
      x11 = XOR(x11, LOAD32_LE(m + 44));
      x12 = XOR(x12, LOAD32_LE(m + 48));
      x13 = XOR(x13, LOAD32_LE(m + 52));
      x14 = XOR(x14, LOAD32_LE(m + 56));
      x15 = XOR(x15, LOAD32_LE(m + 60));
      */
      $x0 = $x0
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 0, 4)));
      $x1 = $x1
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 4, 4)));
      $x2 = $x2
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 8, 4)));
      $x3 = $x3
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 12, 4)));
      $x4 = $x4
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 16, 4)));
      $x5 = $x5
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 20, 4)));
      $x6 = $x6
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 24, 4)));
      $x7 = $x7
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 28, 4)));
      $x8 = $x8
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 32, 4)));
      $x9 = $x9
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 36, 4)));
      $x10 = $x10
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 40, 4)));
      $x11 = $x11
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 44, 4)));
      $x12 = $x12
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 48, 4)));
      $x13 = $x13
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 52, 4)));
      $x14 = $x14
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 56, 4)));
      $x15 = $x15
        ->xorInt32(ParagonIE_Sodium_Core32_Int32::fromReverseString(self::substr($message, 60, 4)));

      /*
         j12 = PLUSONE(j12);
         if (!j12) {
             j13 = PLUSONE(j13);
         }
      */

      /** @var ParagonIE_Sodium_Core32_Int32 $j12 */
      $j12 = $j12
        ->addInt(1);
      if ($j12->limbs[0] === 0 && $j12->limbs[1] === 0) {
        $j13 = $j13
          ->addInt(1);
      }

      /*
      STORE32_LE(c + 0, x0);
      STORE32_LE(c + 4, x1);
      STORE32_LE(c + 8, x2);
      STORE32_LE(c + 12, x3);
      STORE32_LE(c + 16, x4);
      STORE32_LE(c + 20, x5);
      STORE32_LE(c + 24, x6);
      STORE32_LE(c + 28, x7);
      STORE32_LE(c + 32, x8);
      STORE32_LE(c + 36, x9);
      STORE32_LE(c + 40, x10);
      STORE32_LE(c + 44, x11);
      STORE32_LE(c + 48, x12);
      STORE32_LE(c + 52, x13);
      STORE32_LE(c + 56, x14);
      STORE32_LE(c + 60, x15);
      */
      $block = $x0
        ->toReverseString() . $x1
        ->toReverseString() . $x2
        ->toReverseString() . $x3
        ->toReverseString() . $x4
        ->toReverseString() . $x5
        ->toReverseString() . $x6
        ->toReverseString() . $x7
        ->toReverseString() . $x8
        ->toReverseString() . $x9
        ->toReverseString() . $x10
        ->toReverseString() . $x11
        ->toReverseString() . $x12
        ->toReverseString() . $x13
        ->toReverseString() . $x14
        ->toReverseString() . $x15
        ->toReverseString();

      /* Partial block */
      if ($bytes < 64) {
        $c .= self::substr($block, 0, $bytes);
        break;
      }

      /* Full block */
      $c .= $block;
      $bytes -= 64;
      if ($bytes <= 0) {
        break;
      }
      $message = self::substr($message, 64);
    }

    /* end for(;;) loop */
    $ctx[12] = $j12;
    $ctx[13] = $j13;
    return $c;
  }

  /**
   * @internal You should not use this directly from another application
   *
   * @param int $len
   * @param string $nonce
   * @param string $key
   * @return string
   * @throws SodiumException
   * @throws TypeError
   */
  public static function stream($len = 64, $nonce = '', $key = '') {
    return self::encryptBytes(new ParagonIE_Sodium_Core32_ChaCha20_Ctx($key, $nonce), str_repeat("\0", $len));
  }

  /**
   * @internal You should not use this directly from another application
   *
   * @param int $len
   * @param string $nonce
   * @param string $key
   * @return string
   * @throws SodiumException
   * @throws TypeError
   */
  public static function ietfStream($len, $nonce = '', $key = '') {
    return self::encryptBytes(new ParagonIE_Sodium_Core32_ChaCha20_IetfCtx($key, $nonce), str_repeat("\0", $len));
  }

  /**
   * @internal You should not use this directly from another application
   *
   * @param string $message
   * @param string $nonce
   * @param string $key
   * @param string $ic
   * @return string
   * @throws SodiumException
   * @throws TypeError
   */
  public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '') {
    return self::encryptBytes(new ParagonIE_Sodium_Core32_ChaCha20_IetfCtx($key, $nonce, $ic), $message);
  }

  /**
   * @internal You should not use this directly from another application
   *
   * @param string $message
   * @param string $nonce
   * @param string $key
   * @param string $ic
   * @return string
   * @throws SodiumException
   * @throws TypeError
   */
  public static function streamXorIc($message, $nonce = '', $key = '', $ic = '') {
    return self::encryptBytes(new ParagonIE_Sodium_Core32_ChaCha20_Ctx($key, $nonce, $ic), $message);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
ParagonIE_Sodium_Core32_ChaCha20::encryptBytes	public static	function	@internal You should not use this directly from another application
ParagonIE_Sodium_Core32_ChaCha20::ietfStream	public static	function	@internal You should not use this directly from another application
ParagonIE_Sodium_Core32_ChaCha20::ietfStreamXorIc	public static	function	@internal You should not use this directly from another application
ParagonIE_Sodium_Core32_ChaCha20::quarterRound	protected static	function	The ChaCha20 quarter round function. Works on four 32-bit integers.
ParagonIE_Sodium_Core32_ChaCha20::stream	public static	function	@internal You should not use this directly from another application	1
ParagonIE_Sodium_Core32_ChaCha20::streamXorIc	public static	function	@internal You should not use this directly from another application	1
ParagonIE_Sodium_Core_Util::abs	public static	function
ParagonIE_Sodium_Core_Util::bin2hex	public static	function	Convert a binary string into a hexadecimal string without cache-timing leaks
ParagonIE_Sodium_Core_Util::bin2hexUpper	public static	function	Convert a binary string into a hexadecimal string without cache-timing leaks, returning uppercase letters (as per RFC 4648)
ParagonIE_Sodium_Core_Util::chrToInt	public static	function	Cache-timing-safe variant of ord()
ParagonIE_Sodium_Core_Util::compare	public static	function	Compares two strings.
ParagonIE_Sodium_Core_Util::declareScalarType	public static	function	If a variable does not match a given type, throw a TypeError.
ParagonIE_Sodium_Core_Util::hashEquals	public static	function	Evaluate whether or not two strings are equal (in constant-time)
ParagonIE_Sodium_Core_Util::hex2bin	public static	function	Convert a hexadecimal string into a binary string without cache-timing leaks
ParagonIE_Sodium_Core_Util::intArrayToString	public static	function	Turn an array of integers into a string
ParagonIE_Sodium_Core_Util::intToChr	public static	function	Cache-timing-safe variant of ord()
ParagonIE_Sodium_Core_Util::isMbStringOverride	protected static	function	Returns whether or not mbstring.func_overload is in effect.
ParagonIE_Sodium_Core_Util::load64_le	public static	function	Load a 8 character substring into an integer
ParagonIE_Sodium_Core_Util::load_3	public static	function	Load a 3 character substring into an integer
ParagonIE_Sodium_Core_Util::load_4	public static	function	Load a 4 character substring into an integer
ParagonIE_Sodium_Core_Util::memcmp	public static	function	@internal You should not use this directly from another application
ParagonIE_Sodium_Core_Util::mul	public static	function	Multiply two integers in constant-time
ParagonIE_Sodium_Core_Util::numericTo64BitInteger	public static	function	Convert any arbitrary numbers into two 32-bit integers that represent a 64-bit integer.
ParagonIE_Sodium_Core_Util::store32_le	public static	function	Store a 32-bit integer into a string, treating it as little-endian.
ParagonIE_Sodium_Core_Util::store64_le	public static	function	Stores a 64-bit integer as an string, treating it as little-endian.
ParagonIE_Sodium_Core_Util::store_3	public static	function	Store a 24-bit integer into a string, treating it as big-endian.
ParagonIE_Sodium_Core_Util::store_4	public static	function	Store a 32-bit integer into a string, treating it as big-endian.
ParagonIE_Sodium_Core_Util::stringToIntArray	public static	function	Turn a string into an array of integers
ParagonIE_Sodium_Core_Util::strlen	public static	function	Safe string length
ParagonIE_Sodium_Core_Util::substr	public static	function	Safe substring
ParagonIE_Sodium_Core_Util::verify_16	public static	function	Compare a 16-character byte string in constant time.
ParagonIE_Sodium_Core_Util::verify_32	public static	function	Compare a 32-character byte string in constant time.
ParagonIE_Sodium_Core_Util::xorStrings	public static	function	Calculate $a ^ $b for two strings.

You are here

class ParagonIE_Sodium_Core32_ChaCha20 in Automatic Updates 8

Hierarchy

File

Members

API Navigation