class ParagonIE_Sodium_Core32_SipHash in Automatic Updates 7

Same name and namespace in other branches

8 vendor/paragonie/sodium_compat/src/Core32/SipHash.php \ParagonIE_Sodium_Core32_SipHash

Class ParagonIE_SodiumCompat_Core32_SipHash

Only uses 32-bit arithmetic, while the original SipHash used 64-bit integers

Hierarchy

class \ParagonIE_Sodium_Core_Util
- class \ParagonIE_Sodium_Core32_Util
  - class \ParagonIE_Sodium_Core32_SipHash

Expanded class hierarchy of ParagonIE_Sodium_Core32_SipHash

1 string reference to 'ParagonIE_Sodium_Core32_SipHash'

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

File

vendor/paragonie/sodium_compat/src/Core32/SipHash.php, line 12

View source

class ParagonIE_Sodium_Core32_SipHash extends ParagonIE_Sodium_Core32_Util {

  /**
   * @internal You should not use this directly from another application
   *
   * @param array<int, ParagonIE_Sodium_Core32_Int64> $v
   * @return array<int, ParagonIE_Sodium_Core32_Int64>
   */
  public static function sipRound(array $v) {

    # v0 += v1;
    $v[0] = $v[0]
      ->addInt64($v[1]);

    # v1 = ROTL(v1, 13);
    $v[1] = $v[1]
      ->rotateLeft(13);

    #  v1 ^= v0;
    $v[1] = $v[1]
      ->xorInt64($v[0]);

    #  v0=ROTL(v0,32);
    $v[0] = $v[0]
      ->rotateLeft(32);

    # v2 += v3;
    $v[2] = $v[2]
      ->addInt64($v[3]);

    # v3=ROTL(v3,16);
    $v[3] = $v[3]
      ->rotateLeft(16);

    #  v3 ^= v2;
    $v[3] = $v[3]
      ->xorInt64($v[2]);

    # v0 += v3;
    $v[0] = $v[0]
      ->addInt64($v[3]);

    # v3=ROTL(v3,21);
    $v[3] = $v[3]
      ->rotateLeft(21);

    # v3 ^= v0;
    $v[3] = $v[3]
      ->xorInt64($v[0]);

    # v2 += v1;
    $v[2] = $v[2]
      ->addInt64($v[1]);

    # v1=ROTL(v1,17);
    $v[1] = $v[1]
      ->rotateLeft(17);

    #  v1 ^= v2;
    $v[1] = $v[1]
      ->xorInt64($v[2]);

    # v2=ROTL(v2,32)
    $v[2] = $v[2]
      ->rotateLeft(32);
    return $v;
  }

  /**
   * @internal You should not use this directly from another application
   *
   * @param string $in
   * @param string $key
   * @return string
   * @throws SodiumException
   * @throws TypeError
   */
  public static function sipHash24($in, $key) {
    $inlen = self::strlen($in);

    # /* "somepseudorandomlygeneratedbytes" */

    # u64 v0 = 0x736f6d6570736575ULL;

    # u64 v1 = 0x646f72616e646f6dULL;

    # u64 v2 = 0x6c7967656e657261ULL;

    # u64 v3 = 0x7465646279746573ULL;
    $v = array(
      new ParagonIE_Sodium_Core32_Int64(array(
        0x736f,
        0x6d65,
        0x7073,
        0x6575,
      )),
      new ParagonIE_Sodium_Core32_Int64(array(
        0x646f,
        0x7261,
        0x6e64,
        0x6f6d,
      )),
      new ParagonIE_Sodium_Core32_Int64(array(
        0x6c79,
        0x6765,
        0x6e65,
        0x7261,
      )),
      new ParagonIE_Sodium_Core32_Int64(array(
        0x7465,
        0x6462,
        0x7974,
        0x6573,
      )),
    );

    # u64 k0 = LOAD64_LE( k );

    # u64 k1 = LOAD64_LE( k + 8 );
    $k = array(
      ParagonIE_Sodium_Core32_Int64::fromReverseString(self::substr($key, 0, 8)),
      ParagonIE_Sodium_Core32_Int64::fromReverseString(self::substr($key, 8, 8)),
    );

    # b = ( ( u64 )inlen ) << 56;
    $b = new ParagonIE_Sodium_Core32_Int64(array(
      $inlen << 8 & 0xffff,
      0,
      0,
      0,
    ));

    # v3 ^= k1;
    $v[3] = $v[3]
      ->xorInt64($k[1]);

    # v2 ^= k0;
    $v[2] = $v[2]
      ->xorInt64($k[0]);

    # v1 ^= k1;
    $v[1] = $v[1]
      ->xorInt64($k[1]);

    # v0 ^= k0;
    $v[0] = $v[0]
      ->xorInt64($k[0]);
    $left = $inlen;

    # for ( ; in != end; in += 8 )
    while ($left >= 8) {

      # m = LOAD64_LE( in );
      $m = ParagonIE_Sodium_Core32_Int64::fromReverseString(self::substr($in, 0, 8));

      # v3 ^= m;
      $v[3] = $v[3]
        ->xorInt64($m);

      # SIPROUND;

      # SIPROUND;
      $v = self::sipRound($v);
      $v = self::sipRound($v);

      # v0 ^= m;
      $v[0] = $v[0]
        ->xorInt64($m);
      $in = self::substr($in, 8);
      $left -= 8;
    }

    # switch( left )

    #  {

    #     case 7: b |= ( ( u64 )in[ 6] )  << 48;

    #     case 6: b |= ( ( u64 )in[ 5] )  << 40;

    #     case 5: b |= ( ( u64 )in[ 4] )  << 32;

    #     case 4: b |= ( ( u64 )in[ 3] )  << 24;

    #     case 3: b |= ( ( u64 )in[ 2] )  << 16;

    #     case 2: b |= ( ( u64 )in[ 1] )  <<  8;

    #     case 1: b |= ( ( u64 )in[ 0] ); break;

    #     case 0: break;

    # }
    switch ($left) {
      case 7:
        $b = $b
          ->orInt64(ParagonIE_Sodium_Core32_Int64::fromInts(0, self::chrToInt($in[6]) << 16));
      case 6:
        $b = $b
          ->orInt64(ParagonIE_Sodium_Core32_Int64::fromInts(0, self::chrToInt($in[5]) << 8));
      case 5:
        $b = $b
          ->orInt64(ParagonIE_Sodium_Core32_Int64::fromInts(0, self::chrToInt($in[4])));
      case 4:
        $b = $b
          ->orInt64(ParagonIE_Sodium_Core32_Int64::fromInts(self::chrToInt($in[3]) << 24, 0));
      case 3:
        $b = $b
          ->orInt64(ParagonIE_Sodium_Core32_Int64::fromInts(self::chrToInt($in[2]) << 16, 0));
      case 2:
        $b = $b
          ->orInt64(ParagonIE_Sodium_Core32_Int64::fromInts(self::chrToInt($in[1]) << 8, 0));
      case 1:
        $b = $b
          ->orInt64(ParagonIE_Sodium_Core32_Int64::fromInts(self::chrToInt($in[0]), 0));
      case 0:
        break;
    }

    # v3 ^= b;
    $v[3] = $v[3]
      ->xorInt64($b);

    # SIPROUND;

    # SIPROUND;
    $v = self::sipRound($v);
    $v = self::sipRound($v);

    # v0 ^= b;
    $v[0] = $v[0]
      ->xorInt64($b);

    // Flip the lower 8 bits of v2 which is ($v[4], $v[5]) in our implementation

    # v2 ^= 0xff;
    $v[2]->limbs[3] ^= 0xff;

    # SIPROUND;

    # SIPROUND;

    # SIPROUND;

    # SIPROUND;
    $v = self::sipRound($v);
    $v = self::sipRound($v);
    $v = self::sipRound($v);
    $v = self::sipRound($v);

    # b = v0 ^ v1 ^ v2 ^ v3;

    # STORE64_LE( out, b );
    return $v[0]
      ->xorInt64($v[1])
      ->xorInt64($v[2])
      ->xorInt64($v[3])
      ->toReverseString();
  }

}

Members

Name	Modifiers	Type	Description
ParagonIE_Sodium_Core32_SipHash::sipHash24	public static	function	@internal You should not use this directly from another application
ParagonIE_Sodium_Core32_SipHash::sipRound	public static	function	@internal You should not use this directly from another application
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_SipHash in Automatic Updates 7

Hierarchy

File

Members

API Navigation