9
|
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 |
} |