Edit File by line

<?php

[0] Fix | Delete

[1] Fix | Delete

if (class_exists('ParagonIE_Sodium_Core_BLAKE2b', false)) {

[2] Fix | Delete

return;

[3] Fix | Delete

}

[4] Fix | Delete

[5] Fix | Delete

/**

[6] Fix | Delete

* Class ParagonIE_Sodium_Core_BLAKE2b

[7] Fix | Delete

[8] Fix | Delete

* Based on the work of Devi Mandiri in devi/salt.

[9] Fix | Delete

[10] Fix | Delete

abstract class ParagonIE_Sodium_Core_BLAKE2b extends ParagonIE_Sodium_Core_Util

[11] Fix | Delete

{

[12] Fix | Delete

/**

[13] Fix | Delete

* @var SplFixedArray

[14] Fix | Delete

[15] Fix | Delete

protected static $iv;

[16] Fix | Delete

[17] Fix | Delete

/**

[18] Fix | Delete

* @var array<int, array<int, int>>

[19] Fix | Delete

[20] Fix | Delete

protected static $sigma = array(

[21] Fix | Delete

array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15),

[22] Fix | Delete

array( 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3),

[23] Fix | Delete

array( 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4),

[24] Fix | Delete

array( 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8),

[25] Fix | Delete

array( 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13),

[26] Fix | Delete

array( 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9),

[27] Fix | Delete

array( 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11),

[28] Fix | Delete

array( 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10),

[29] Fix | Delete

array( 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5),

[30] Fix | Delete

array( 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0),

[31] Fix | Delete

array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15),

[32] Fix | Delete

array( 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3)

[33] Fix | Delete

);

[34] Fix | Delete

[35] Fix | Delete

const BLOCKBYTES = 128;

[36] Fix | Delete

const OUTBYTES = 64;

[37] Fix | Delete

const KEYBYTES = 64;

[38] Fix | Delete

[39] Fix | Delete

/**

[40] Fix | Delete

* Turn two 32-bit integers into a fixed array representing a 64-bit integer.

[41] Fix | Delete

[42] Fix | Delete

* @internal You should not use this directly from another application

[43] Fix | Delete

[44] Fix | Delete

* @param int $high

[45] Fix | Delete

* @param int $low

[46] Fix | Delete

* @return SplFixedArray

[47] Fix | Delete

* @psalm-suppress MixedAssignment

[48] Fix | Delete

[49] Fix | Delete

public static function new64($high, $low)

[50] Fix | Delete

{

[51] Fix | Delete

if (PHP_INT_SIZE === 4) {

[52] Fix | Delete

throw new SodiumException("Error, use 32-bit");

[53] Fix | Delete

}

[54] Fix | Delete

$i64 = new SplFixedArray(2);

[55] Fix | Delete

$i64[0] = $high & 0xffffffff;

[56] Fix | Delete

$i64[1] = $low & 0xffffffff;

[57] Fix | Delete

return $i64;

[58] Fix | Delete

}

[59] Fix | Delete

[60] Fix | Delete

/**

[61] Fix | Delete

* Convert an arbitrary number into an SplFixedArray of two 32-bit integers

[62] Fix | Delete

* that represents a 64-bit integer.

[63] Fix | Delete

[64] Fix | Delete

* @internal You should not use this directly from another application

[65] Fix | Delete

[66] Fix | Delete

* @param int $num

[67] Fix | Delete

* @return SplFixedArray

[68] Fix | Delete

[69] Fix | Delete

protected static function to64($num)

[70] Fix | Delete

{

[71] Fix | Delete

list($hi, $lo) = self::numericTo64BitInteger($num);

[72] Fix | Delete

return self::new64($hi, $lo);

[73] Fix | Delete

}

[74] Fix | Delete

[75] Fix | Delete

/**

[76] Fix | Delete

* Adds two 64-bit integers together, returning their sum as a SplFixedArray

[77] Fix | Delete

* containing two 32-bit integers (representing a 64-bit integer).

[78] Fix | Delete

[79] Fix | Delete

* @internal You should not use this directly from another application

[80] Fix | Delete

[81] Fix | Delete

* @param SplFixedArray $x

[82] Fix | Delete

* @param SplFixedArray $y

[83] Fix | Delete

* @return SplFixedArray

[84] Fix | Delete

* @psalm-suppress MixedArgument

[85] Fix | Delete

* @psalm-suppress MixedAssignment

[86] Fix | Delete

* @psalm-suppress MixedOperand

[87] Fix | Delete

[88] Fix | Delete

protected static function add64($x, $y)

[89] Fix | Delete

{

[90] Fix | Delete

if (PHP_INT_SIZE === 4) {

[91] Fix | Delete

throw new SodiumException("Error, use 32-bit");

[92] Fix | Delete

}

[93] Fix | Delete

$l = ($x[1] + $y[1]) & 0xffffffff;

[94] Fix | Delete

return self::new64(

[95] Fix | Delete

(int) ($x[0] + $y[0] + (

[96] Fix | Delete

($l < $x[1]) ? 1 : 0

[97] Fix | Delete

)),

[98] Fix | Delete

(int) $l

[99] Fix | Delete

);

[100] Fix | Delete

}

[101] Fix | Delete

[102] Fix | Delete

/**

[103] Fix | Delete

* @internal You should not use this directly from another application

[104] Fix | Delete

[105] Fix | Delete

* @param SplFixedArray $x

[106] Fix | Delete

* @param SplFixedArray $y

[107] Fix | Delete

* @param SplFixedArray $z

[108] Fix | Delete

* @return SplFixedArray

[109] Fix | Delete

[110] Fix | Delete

protected static function add364($x, $y, $z)

[111] Fix | Delete

{

[112] Fix | Delete

return self::add64($x, self::add64($y, $z));

[113] Fix | Delete

}

[114] Fix | Delete

[115] Fix | Delete

/**

[116] Fix | Delete

* @internal You should not use this directly from another application

[117] Fix | Delete

[118] Fix | Delete

* @param SplFixedArray $x

[119] Fix | Delete

* @param SplFixedArray $y

[120] Fix | Delete

* @return SplFixedArray

[121] Fix | Delete

* @throws SodiumException

[122] Fix | Delete

* @throws TypeError

[123] Fix | Delete

[124] Fix | Delete

protected static function xor64(SplFixedArray $x, SplFixedArray $y)

[125] Fix | Delete

{

[126] Fix | Delete

if (PHP_INT_SIZE === 4) {

[127] Fix | Delete

throw new SodiumException("Error, use 32-bit");

[128] Fix | Delete

}

[129] Fix | Delete

if (!is_numeric($x[0])) {

[130] Fix | Delete

throw new SodiumException('x[0] is not an integer');

[131] Fix | Delete

}

[132] Fix | Delete

if (!is_numeric($x[1])) {

[133] Fix | Delete

throw new SodiumException('x[1] is not an integer');

[134] Fix | Delete

}

[135] Fix | Delete

if (!is_numeric($y[0])) {

[136] Fix | Delete

throw new SodiumException('y[0] is not an integer');

[137] Fix | Delete

}

[138] Fix | Delete

if (!is_numeric($y[1])) {

[139] Fix | Delete

throw new SodiumException('y[1] is not an integer');

[140] Fix | Delete

}

[141] Fix | Delete

return self::new64(

[142] Fix | Delete

(int) (($x[0] ^ $y[0]) & 0xffffffff),

[143] Fix | Delete

(int) (($x[1] ^ $y[1]) & 0xffffffff)

[144] Fix | Delete

);

[145] Fix | Delete

}

[146] Fix | Delete

[147] Fix | Delete

/**

[148] Fix | Delete

* @internal You should not use this directly from another application

[149] Fix | Delete

[150] Fix | Delete

* @param SplFixedArray $x

[151] Fix | Delete

* @param int $c

[152] Fix | Delete

* @return SplFixedArray

[153] Fix | Delete

* @psalm-suppress MixedAssignment

[154] Fix | Delete

[155] Fix | Delete

public static function rotr64($x, $c)

[156] Fix | Delete

{

[157] Fix | Delete

if (PHP_INT_SIZE === 4) {

[158] Fix | Delete

throw new SodiumException("Error, use 32-bit");

[159] Fix | Delete

}

[160] Fix | Delete

if ($c >= 64) {

[161] Fix | Delete

$c %= 64;

[162] Fix | Delete

}

[163] Fix | Delete

if ($c >= 32) {

[164] Fix | Delete

/** @var int $tmp */

[165] Fix | Delete

$tmp = $x[0];

[166] Fix | Delete

$x[0] = $x[1];

[167] Fix | Delete

$x[1] = $tmp;

[168] Fix | Delete

$c -= 32;

[169] Fix | Delete

}

[170] Fix | Delete

if ($c === 0) {

[171] Fix | Delete

return $x;

[172] Fix | Delete

}

[173] Fix | Delete

[174] Fix | Delete

$l0 = 0;

[175] Fix | Delete

$c = 64 - $c;

[176] Fix | Delete

[177] Fix | Delete

/** @var int $c */

[178] Fix | Delete

if ($c < 32) {

[179] Fix | Delete

$h0 = ((int) ($x[0]) << $c) | (

[180] Fix | Delete

(

[181] Fix | Delete

(int) ($x[1]) & ((1 << $c) - 1)

[182] Fix | Delete

[183] Fix | Delete

(32 - $c)

[184] Fix | Delete

) >> (32 - $c)

[185] Fix | Delete

);

[186] Fix | Delete

$l0 = (int) ($x[1]) << $c;

[187] Fix | Delete

} else {

[188] Fix | Delete

$h0 = (int) ($x[1]) << ($c - 32);

[189] Fix | Delete

}

[190] Fix | Delete

[191] Fix | Delete

$h1 = 0;

[192] Fix | Delete

$c1 = 64 - $c;

[193] Fix | Delete

[194] Fix | Delete

if ($c1 < 32) {

[195] Fix | Delete

$h1 = (int) ($x[0]) >> $c1;

[196] Fix | Delete

$l1 = ((int) ($x[1]) >> $c1) | ((int) ($x[0]) & ((1 << $c1) - 1)) << (32 - $c1);

[197] Fix | Delete

} else {

[198] Fix | Delete

$l1 = (int) ($x[0]) >> ($c1 - 32);

[199] Fix | Delete

}

[200] Fix | Delete

[201] Fix | Delete

return self::new64($h0 | $h1, $l0 | $l1);

[202] Fix | Delete

}

[203] Fix | Delete

[204] Fix | Delete

/**

[205] Fix | Delete

* @internal You should not use this directly from another application

[206] Fix | Delete

[207] Fix | Delete

* @param SplFixedArray $x

[208] Fix | Delete

* @return int

[209] Fix | Delete

* @psalm-suppress MixedOperand

[210] Fix | Delete

[211] Fix | Delete

protected static function flatten64($x)

[212] Fix | Delete

{

[213] Fix | Delete

return (int) ($x[0] * 4294967296 + $x[1]);

[214] Fix | Delete

}

[215] Fix | Delete

[216] Fix | Delete

/**

[217] Fix | Delete

* @internal You should not use this directly from another application

[218] Fix | Delete

[219] Fix | Delete

* @param SplFixedArray $x

[220] Fix | Delete

* @param int $i

[221] Fix | Delete

* @return SplFixedArray

[222] Fix | Delete

* @psalm-suppress MixedArgument

[223] Fix | Delete

* @psalm-suppress MixedArrayOffset

[224] Fix | Delete

[225] Fix | Delete

protected static function load64(SplFixedArray $x, $i)

[226] Fix | Delete

{

[227] Fix | Delete

/** @var int $l */

[228] Fix | Delete

$l = (int) ($x[$i])

[229] Fix | Delete

| ((int) ($x[$i+1]) << 8)

[230] Fix | Delete

| ((int) ($x[$i+2]) << 16)

[231] Fix | Delete

| ((int) ($x[$i+3]) << 24);

[232] Fix | Delete

/** @var int $h */

[233] Fix | Delete

$h = (int) ($x[$i+4])

[234] Fix | Delete

| ((int) ($x[$i+5]) << 8)

[235] Fix | Delete

| ((int) ($x[$i+6]) << 16)

[236] Fix | Delete

| ((int) ($x[$i+7]) << 24);

[237] Fix | Delete

return self::new64($h, $l);

[238] Fix | Delete

}

[239] Fix | Delete

[240] Fix | Delete

/**

[241] Fix | Delete

* @internal You should not use this directly from another application

[242] Fix | Delete

[243] Fix | Delete

* @param SplFixedArray $x

[244] Fix | Delete

* @param int $i

[245] Fix | Delete

* @param SplFixedArray $u

[246] Fix | Delete

* @return void

[247] Fix | Delete

* @psalm-suppress MixedAssignment

[248] Fix | Delete

[249] Fix | Delete

protected static function store64(SplFixedArray $x, $i, SplFixedArray $u)

[250] Fix | Delete

{

[251] Fix | Delete

$maxLength = $x->getSize() - 1;

[252] Fix | Delete

for ($j = 0; $j < 8; ++$j) {

[253] Fix | Delete

[254] Fix | Delete

[0, 1, 2, 3, 4, 5, 6, 7]

[255] Fix | Delete

... becomes ...

[256] Fix | Delete

[0, 0, 0, 0, 1, 1, 1, 1]

[257] Fix | Delete

[258] Fix | Delete

/** @var int $uIdx */

[259] Fix | Delete

$uIdx = ((7 - $j) & 4) >> 2;

[260] Fix | Delete

$x[$i] = ((int) ($u[$uIdx]) & 0xff);

[261] Fix | Delete

if (++$i > $maxLength) {

[262] Fix | Delete

return;

[263] Fix | Delete

}

[264] Fix | Delete

/** @psalm-suppress MixedOperand */

[265] Fix | Delete

$u[$uIdx] >>= 8;

[266] Fix | Delete

}

[267] Fix | Delete

}

[268] Fix | Delete

[269] Fix | Delete

/**

[270] Fix | Delete

* This just sets the $iv static variable.

[271] Fix | Delete

[272] Fix | Delete

* @internal You should not use this directly from another application

[273] Fix | Delete

[274] Fix | Delete

* @return void

[275] Fix | Delete

[276] Fix | Delete

public static function pseudoConstructor()

[277] Fix | Delete

{

[278] Fix | Delete

static $called = false;

[279] Fix | Delete

if ($called) {

[280] Fix | Delete

return;

[281] Fix | Delete

}

[282] Fix | Delete

self::$iv = new SplFixedArray(8);

[283] Fix | Delete

self::$iv[0] = self::new64(0x6a09e667, 0xf3bcc908);

[284] Fix | Delete

self::$iv[1] = self::new64(0xbb67ae85, 0x84caa73b);

[285] Fix | Delete

self::$iv[2] = self::new64(0x3c6ef372, 0xfe94f82b);

[286] Fix | Delete

self::$iv[3] = self::new64(0xa54ff53a, 0x5f1d36f1);

[287] Fix | Delete

self::$iv[4] = self::new64(0x510e527f, 0xade682d1);

[288] Fix | Delete

self::$iv[5] = self::new64(0x9b05688c, 0x2b3e6c1f);

[289] Fix | Delete

self::$iv[6] = self::new64(0x1f83d9ab, 0xfb41bd6b);

[290] Fix | Delete

self::$iv[7] = self::new64(0x5be0cd19, 0x137e2179);

[291] Fix | Delete

[292] Fix | Delete

$called = true;

[293] Fix | Delete

}

[294] Fix | Delete

[295] Fix | Delete

/**

[296] Fix | Delete

* Returns a fresh BLAKE2 context.

[297] Fix | Delete

[298] Fix | Delete

* @internal You should not use this directly from another application

[299] Fix | Delete

[300] Fix | Delete

* @return SplFixedArray

[301] Fix | Delete

* @psalm-suppress MixedAssignment

[302] Fix | Delete

* @psalm-suppress MixedArrayAccess

[303] Fix | Delete

* @psalm-suppress MixedArrayAssignment

[304] Fix | Delete

[305] Fix | Delete

protected static function context()

[306] Fix | Delete

{

[307] Fix | Delete

$ctx = new SplFixedArray(6);

[308] Fix | Delete

$ctx[0] = new SplFixedArray(8); // h

[309] Fix | Delete

$ctx[1] = new SplFixedArray(2); // t

[310] Fix | Delete

$ctx[2] = new SplFixedArray(2); // f

[311] Fix | Delete

$ctx[3] = new SplFixedArray(256); // buf

[312] Fix | Delete

$ctx[4] = 0; // buflen

[313] Fix | Delete

$ctx[5] = 0; // last_node (uint8_t)

[314] Fix | Delete

[315] Fix | Delete

for ($i = 8; $i--;) {

[316] Fix | Delete

$ctx[0][$i] = self::$iv[$i];

[317] Fix | Delete

}

[318] Fix | Delete

for ($i = 256; $i--;) {

[319] Fix | Delete

$ctx[3][$i] = 0;

[320] Fix | Delete

}

[321] Fix | Delete

[322] Fix | Delete

$zero = self::new64(0, 0);

[323] Fix | Delete

$ctx[1][0] = $zero;

[324] Fix | Delete

$ctx[1][1] = $zero;

[325] Fix | Delete

$ctx[2][0] = $zero;

[326] Fix | Delete

$ctx[2][1] = $zero;

[327] Fix | Delete

[328] Fix | Delete

return $ctx;

[329] Fix | Delete

}

[330] Fix | Delete

[331] Fix | Delete

/**

[332] Fix | Delete

* @internal You should not use this directly from another application

[333] Fix | Delete

[334] Fix | Delete

* @param SplFixedArray $ctx

[335] Fix | Delete

* @param SplFixedArray $buf

[336] Fix | Delete

* @return void

[337] Fix | Delete

* @throws SodiumException

[338] Fix | Delete

* @throws TypeError

[339] Fix | Delete

* @psalm-suppress MixedArgument

[340] Fix | Delete

* @psalm-suppress MixedAssignment

[341] Fix | Delete

* @psalm-suppress MixedArrayAccess

[342] Fix | Delete

* @psalm-suppress MixedArrayAssignment

[343] Fix | Delete

* @psalm-suppress MixedArrayOffset

[344] Fix | Delete

[345] Fix | Delete

protected static function compress(SplFixedArray $ctx, SplFixedArray $buf)

[346] Fix | Delete

{

[347] Fix | Delete

$m = new SplFixedArray(16);

[348] Fix | Delete

$v = new SplFixedArray(16);

[349] Fix | Delete

[350] Fix | Delete

for ($i = 16; $i--;) {

[351] Fix | Delete

$m[$i] = self::load64($buf, $i << 3);

[352] Fix | Delete

}

[353] Fix | Delete

[354] Fix | Delete

for ($i = 8; $i--;) {

[355] Fix | Delete

$v[$i] = $ctx[0][$i];

[356] Fix | Delete

}

[357] Fix | Delete

[358] Fix | Delete

$v[ 8] = self::$iv[0];

[359] Fix | Delete

$v[ 9] = self::$iv[1];

[360] Fix | Delete

$v[10] = self::$iv[2];

[361] Fix | Delete

$v[11] = self::$iv[3];

[362] Fix | Delete

[363] Fix | Delete

$v[12] = self::xor64($ctx[1][0], self::$iv[4]);

[364] Fix | Delete

$v[13] = self::xor64($ctx[1][1], self::$iv[5]);

[365] Fix | Delete

$v[14] = self::xor64($ctx[2][0], self::$iv[6]);

[366] Fix | Delete

$v[15] = self::xor64($ctx[2][1], self::$iv[7]);

[367] Fix | Delete

[368] Fix | Delete

for ($r = 0; $r < 12; ++$r) {

[369] Fix | Delete

$v = self::G($r, 0, 0, 4, 8, 12, $v, $m);

[370] Fix | Delete

$v = self::G($r, 1, 1, 5, 9, 13, $v, $m);

[371] Fix | Delete

$v = self::G($r, 2, 2, 6, 10, 14, $v, $m);

[372] Fix | Delete

$v = self::G($r, 3, 3, 7, 11, 15, $v, $m);

[373] Fix | Delete

$v = self::G($r, 4, 0, 5, 10, 15, $v, $m);

[374] Fix | Delete

$v = self::G($r, 5, 1, 6, 11, 12, $v, $m);

[375] Fix | Delete

$v = self::G($r, 6, 2, 7, 8, 13, $v, $m);

[376] Fix | Delete

$v = self::G($r, 7, 3, 4, 9, 14, $v, $m);

[377] Fix | Delete

}

[378] Fix | Delete

[379] Fix | Delete

for ($i = 8; $i--;) {

[380] Fix | Delete

$ctx[0][$i] = self::xor64(

[381] Fix | Delete

$ctx[0][$i], self::xor64($v[$i], $v[$i+8])

[382] Fix | Delete

);

[383] Fix | Delete

}

[384] Fix | Delete

}

[385] Fix | Delete

[386] Fix | Delete

/**

[387] Fix | Delete

* @internal You should not use this directly from another application

[388] Fix | Delete

[389] Fix | Delete

* @param int $r

[390] Fix | Delete

* @param int $i

[391] Fix | Delete

* @param int $a

[392] Fix | Delete

* @param int $b

[393] Fix | Delete

* @param int $c

[394] Fix | Delete

* @param int $d

[395] Fix | Delete

* @param SplFixedArray $v

[396] Fix | Delete

* @param SplFixedArray $m

[397] Fix | Delete

* @return SplFixedArray

[398] Fix | Delete

* @throws SodiumException

[399] Fix | Delete

* @throws TypeError

[400] Fix | Delete

* @psalm-suppress MixedArgument

[401] Fix | Delete

* @psalm-suppress MixedArrayOffset

[402] Fix | Delete

[403] Fix | Delete

public static function G($r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m)

[404] Fix | Delete

{

[405] Fix | Delete

$v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][$i << 1]]);

[406] Fix | Delete

$v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 32);

[407] Fix | Delete

$v[$c] = self::add64($v[$c], $v[$d]);

[408] Fix | Delete

$v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 24);

[409] Fix | Delete

$v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][($i << 1) + 1]]);

[410] Fix | Delete

$v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 16);

[411] Fix | Delete

$v[$c] = self::add64($v[$c], $v[$d]);

[412] Fix | Delete

$v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 63);

[413] Fix | Delete

return $v;

[414] Fix | Delete

}

[415] Fix | Delete

[416] Fix | Delete

/**

[417] Fix | Delete

* @internal You should not use this directly from another application

[418] Fix | Delete

[419] Fix | Delete

* @param SplFixedArray $ctx

[420] Fix | Delete

* @param int $inc

[421] Fix | Delete

* @return void

[422] Fix | Delete

* @throws SodiumException

[423] Fix | Delete

* @psalm-suppress MixedArgument

[424] Fix | Delete

* @psalm-suppress MixedArrayAccess

[425] Fix | Delete

* @psalm-suppress MixedArrayAssignment

[426] Fix | Delete

[427] Fix | Delete

public static function increment_counter($ctx, $inc)

[428] Fix | Delete

{

[429] Fix | Delete

if ($inc < 0) {

[430] Fix | Delete

throw new SodiumException('Increasing by a negative number makes no sense.');

[431] Fix | Delete

}

[432] Fix | Delete

$t = self::to64($inc);

[433] Fix | Delete

# S->t is $ctx[1] in our implementation

[434] Fix | Delete

[435] Fix | Delete

# S->t[0] = ( uint64_t )( t >> 0 );

[436] Fix | Delete

$ctx[1][0] = self::add64($ctx[1][0], $t);

[437] Fix | Delete

[438] Fix | Delete

# S->t[1] += ( S->t[0] < inc );

[439] Fix | Delete

if (self::flatten64($ctx[1][0]) < $inc) {

[440] Fix | Delete

$ctx[1][1] = self::add64($ctx[1][1], self::to64(1));

[441] Fix | Delete

}

[442] Fix | Delete

}

[443] Fix | Delete

[444] Fix | Delete

/**

[445] Fix | Delete

* @internal You should not use this directly from another application

[446] Fix | Delete

[447] Fix | Delete

* @param SplFixedArray $ctx

[448] Fix | Delete

* @param SplFixedArray $p

[449] Fix | Delete

* @param int $plen

[450] Fix | Delete

* @return void

[451] Fix | Delete

* @throws SodiumException

[452] Fix | Delete

* @throws TypeError

[453] Fix | Delete

* @psalm-suppress MixedArgument

[454] Fix | Delete

* @psalm-suppress MixedAssignment

[455] Fix | Delete

* @psalm-suppress MixedArrayAccess

[456] Fix | Delete

* @psalm-suppress MixedArrayAssignment

[457] Fix | Delete

* @psalm-suppress MixedArrayOffset

[458] Fix | Delete

* @psalm-suppress MixedOperand

[459] Fix | Delete

[460] Fix | Delete

public static function update(SplFixedArray $ctx, SplFixedArray $p, $plen)

[461] Fix | Delete

{

[462] Fix | Delete

self::pseudoConstructor();

[463] Fix | Delete

[464] Fix | Delete

$offset = 0;

[465] Fix | Delete

while ($plen > 0) {

[466] Fix | Delete

$left = $ctx[4];

[467] Fix | Delete

$fill = 256 - $left;

[468] Fix | Delete

[469] Fix | Delete

if ($plen > $fill) {

[470] Fix | Delete

# memcpy( S->buf + left, in, fill ); /* Fill buffer */

[471] Fix | Delete

for ($i = $fill; $i--;) {

[472] Fix | Delete

$ctx[3][$i + $left] = $p[$i + $offset];

[473] Fix | Delete

}

[474] Fix | Delete

[475] Fix | Delete

# S->buflen += fill;

[476] Fix | Delete

$ctx[4] += $fill;

[477] Fix | Delete

[478] Fix | Delete

# blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );

[479] Fix | Delete

self::increment_counter($ctx, 128);

[480] Fix | Delete

[481] Fix | Delete

# blake2b_compress( S, S->buf ); /* Compress */

[482] Fix | Delete

self::compress($ctx, $ctx[3]);

[483] Fix | Delete

[484] Fix | Delete

# memcpy( S->buf, S->buf + BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES ); /* Shift buffer left */

[485] Fix | Delete

for ($i = 128; $i--;) {

[486] Fix | Delete

$ctx[3][$i] = $ctx[3][$i + 128];

[487] Fix | Delete

}

[488] Fix | Delete

[489] Fix | Delete

# S->buflen -= BLAKE2B_BLOCKBYTES;

[490] Fix | Delete

$ctx[4] -= 128;

[491] Fix | Delete

[492] Fix | Delete

# in += fill;

[493] Fix | Delete

$offset += $fill;

[494] Fix | Delete

[495] Fix | Delete

# inlen -= fill;

[496] Fix | Delete

$plen -= $fill;

[497] Fix | Delete

} else {

[498] Fix | Delete

for ($i = $plen; $i--;) {

[499] Fix | Delete