PluginProbe
ManageWP Worker / 4.9.25
ManageWP Worker v4.9.25
4.9.38 4.9.37 4.9.36 4.9.35 4.9.34 3.8.7 3.8.8 3.9.0 3.9.1 3.9.10 3.9.11 3.9.12 3.9.13 3.9.14 3.9.15 3.9.16 3.9.17 3.9.18 3.9.19 3.9.2 3.9.20 3.9.21 3.9.22 3.9.23 3.9.24 All 73 releases
worker / src / PHPSecLib / Crypt / DES.php

DES.php in ManageWP Worker 4.9.25, at src/PHPSecLib/Crypt/DES.php

1,514 lines 72.2 KB
No matching file
Up and down to move Enter to open Esc to close
Raw Download Zip
1 <?php
2
3 /**
4 * Pure-PHP implementation of DES.
5 *
6 * Uses mcrypt, if available, and an internal implementation, otherwise.
7 *
8 * PHP versions 4 and 5
9 *
10 * Useful resources are as follows:
11 *
12 * - {@link http://en.wikipedia.org/wiki/DES_supplementary_material Wikipedia: DES supplementary material}
13 * - {@link http://www.itl.nist.gov/fipspubs/fip46-2.htm FIPS 46-2 - (DES), Data Encryption Standard}
14 * - {@link http://www.cs.eku.edu/faculty/styer/460/Encrypt/JS-DES.html JavaScript DES Example}
15 *
16 * Here's a short example of how to use this library:
17 * <code>
18 * <?php
19 * include 'Crypt/DES.php';
20 *
21 * $des = new Crypt_DES();
22 *
23 * $des->setKey('abcdefgh');
24 *
25 * $size = 10 * 1024;
26 * $plaintext = '';
27 * for ($i = 0; $i < $size; $i++) {
28 * $plaintext.= 'a';
29 * }
30 *
31 * echo $des->decrypt($des->encrypt($plaintext));
32 * ?>
33 * </code>
34 *
35 * LICENSE: Permission is hereby granted, free of charge, to any person obtaining a copy
36 * of this software and associated documentation files (the "Software"), to deal
37 * in the Software without restriction, including without limitation the rights
38 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
39 * copies of the Software, and to permit persons to whom the Software is
40 * furnished to do so, subject to the following conditions:
41 *
42 * The above copyright notice and this permission notice shall be included in
43 * all copies or substantial portions of the Software.
44 *
45 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
46 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
47 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
48 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
49 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
50 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
51 * THE SOFTWARE.
52 *
53 * @category Crypt
54 * @package Crypt_DES
55 * @author Jim Wigginton <terrafrost@php.net>
56 * @copyright MMVII Jim Wigginton
57 * @license http://www.opensource.org/licenses/mit-license.html MIT License
58 * @link http://phpseclib.sourceforge.net
59 */
60
61 /**
62 * Include Crypt_Base
63 *
64 * Base cipher class
65 */
66 if (!class_exists('Crypt_Base')) {
67 require_once dirname(__FILE__).'/Base.php';
68 }
69
70 /**#@+
71 * @access private
72 * @see Crypt_DES::_setupKey()
73 * @see Crypt_DES::_processBlock()
74 */
75 /**
76 * Contains $keys[CRYPT_DES_ENCRYPT]
77 */
78 define('CRYPT_DES_ENCRYPT', 0);
79 /**
80 * Contains $keys[CRYPT_DES_DECRYPT]
81 */
82 define('CRYPT_DES_DECRYPT', 1);
83 /**#@-*/
84
85 /**#@+
86 * @access public
87 * @see Crypt_DES::encrypt()
88 * @see Crypt_DES::decrypt()
89 */
90 /**
91 * Encrypt / decrypt using the Counter mode.
92 *
93 * Set to -1 since that's what Crypt/Random.php uses to index the CTR mode.
94 *
95 * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Counter_.28CTR.29
96 */
97 define('CRYPT_DES_MODE_CTR', CRYPT_MODE_CTR);
98 /**
99 * Encrypt / decrypt using the Electronic Code Book mode.
100 *
101 * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Electronic_codebook_.28ECB.29
102 */
103 define('CRYPT_DES_MODE_ECB', CRYPT_MODE_ECB);
104 /**
105 * Encrypt / decrypt using the Code Book Chaining mode.
106 *
107 * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Cipher-block_chaining_.28CBC.29
108 */
109 define('CRYPT_DES_MODE_CBC', CRYPT_MODE_CBC);
110 /**
111 * Encrypt / decrypt using the Cipher Feedback mode.
112 *
113 * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Cipher_feedback_.28CFB.29
114 */
115 define('CRYPT_DES_MODE_CFB', CRYPT_MODE_CFB);
116 /**
117 * Encrypt / decrypt using the Cipher Feedback mode.
118 *
119 * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Output_feedback_.28OFB.29
120 */
121 define('CRYPT_DES_MODE_OFB', CRYPT_MODE_OFB);
122 /**#@-*/
123
124 /**#@+
125 * @access private
126 * @see Crypt_Base::Crypt_Base()
127 */
128 /**
129 * Toggles the internal implementation
130 */
131 define('CRYPT_DES_MODE_INTERNAL', CRYPT_MODE_INTERNAL);
132 /**
133 * Toggles the mcrypt implementation
134 */
135 define('CRYPT_DES_MODE_MCRYPT', CRYPT_MODE_MCRYPT);
136 /**#@-*/
137
138 /**
139 * Pure-PHP implementation of DES.
140 *
141 * @package Crypt_DES
142 * @author Jim Wigginton <terrafrost@php.net>
143 * @access public
144 */
145 class Crypt_DES extends Crypt_Base
146 {
147 /**
148 * Block Length of the cipher
149 *
150 * @see Crypt_Base::block_size
151 * @var Integer
152 * @access private
153 */
154 public $block_size = 8;
155
156 /**
157 * The Key
158 *
159 * @see Crypt_Base::key
160 * @see setKey()
161 * @var String
162 * @access private
163 */
164 public $key = "\0\0\0\0\0\0\0\0";
165
166 /**
167 * The default password key_size used by setPassword()
168 *
169 * @see Crypt_Base::password_key_size
170 * @see Crypt_Base::setPassword()
171 * @var Integer
172 * @access private
173 */
174 public $password_key_size = 8;
175
176 /**
177 * The namespace used by the cipher for its constants.
178 *
179 * @see Crypt_Base::const_namespace
180 * @var String
181 * @access private
182 */
183 public $const_namespace = 'DES';
184
185 /**
186 * The mcrypt specific name of the cipher
187 *
188 * @see Crypt_Base::cipher_name_mcrypt
189 * @var String
190 * @access private
191 */
192 public $cipher_name_mcrypt = 'des';
193
194 /**
195 * Optimizing value while CFB-encrypting
196 *
197 * @see Crypt_Base::cfb_init_len
198 * @var Integer
199 * @access private
200 */
201 public $cfb_init_len = 500;
202
203 /**
204 * Switch for DES/3DES encryption
205 *
206 * Used only if $engine == CRYPT_DES_MODE_INTERNAL
207 *
208 * @see Crypt_DES::_setupKey()
209 * @see Crypt_DES::_processBlock()
210 * @var Integer
211 * @access private
212 */
213 public $des_rounds = 1;
214
215 /**
216 * max possible size of $key
217 *
218 * @see Crypt_DES::setKey()
219 * @var String
220 * @access private
221 */
222 public $key_size_max = 8;
223
224 /**
225 * The Key Schedule
226 *
227 * @see Crypt_DES::_setupKey()
228 * @var Array
229 * @access private
230 */
231 public $keys;
232
233 /**
234 * Shuffle table.
235 *
236 * For each byte value index, the entry holds an 8-byte string
237 * with each byte containing all bits in the same state as the
238 * corresponding bit in the index value.
239 *
240 * @see Crypt_DES::_processBlock()
241 * @see Crypt_DES::_setupKey()
242 * @var Array
243 * @access private
244 */
245 var $shuffle = array(
246 "\x00\x00\x00\x00\x00\x00\x00\x00", "\x00\x00\x00\x00\x00\x00\x00\xFF",
247 "\x00\x00\x00\x00\x00\x00\xFF\x00", "\x00\x00\x00\x00\x00\x00\xFF\xFF",
248 "\x00\x00\x00\x00\x00\xFF\x00\x00", "\x00\x00\x00\x00\x00\xFF\x00\xFF",
249 "\x00\x00\x00\x00\x00\xFF\xFF\x00", "\x00\x00\x00\x00\x00\xFF\xFF\xFF",
250 "\x00\x00\x00\x00\xFF\x00\x00\x00", "\x00\x00\x00\x00\xFF\x00\x00\xFF",
251 "\x00\x00\x00\x00\xFF\x00\xFF\x00", "\x00\x00\x00\x00\xFF\x00\xFF\xFF",
252 "\x00\x00\x00\x00\xFF\xFF\x00\x00", "\x00\x00\x00\x00\xFF\xFF\x00\xFF",
253 "\x00\x00\x00\x00\xFF\xFF\xFF\x00", "\x00\x00\x00\x00\xFF\xFF\xFF\xFF",
254 "\x00\x00\x00\xFF\x00\x00\x00\x00", "\x00\x00\x00\xFF\x00\x00\x00\xFF",
255 "\x00\x00\x00\xFF\x00\x00\xFF\x00", "\x00\x00\x00\xFF\x00\x00\xFF\xFF",
256 "\x00\x00\x00\xFF\x00\xFF\x00\x00", "\x00\x00\x00\xFF\x00\xFF\x00\xFF",
257 "\x00\x00\x00\xFF\x00\xFF\xFF\x00", "\x00\x00\x00\xFF\x00\xFF\xFF\xFF",
258 "\x00\x00\x00\xFF\xFF\x00\x00\x00", "\x00\x00\x00\xFF\xFF\x00\x00\xFF",
259 "\x00\x00\x00\xFF\xFF\x00\xFF\x00", "\x00\x00\x00\xFF\xFF\x00\xFF\xFF",
260 "\x00\x00\x00\xFF\xFF\xFF\x00\x00", "\x00\x00\x00\xFF\xFF\xFF\x00\xFF",
261 "\x00\x00\x00\xFF\xFF\xFF\xFF\x00", "\x00\x00\x00\xFF\xFF\xFF\xFF\xFF",
262 "\x00\x00\xFF\x00\x00\x00\x00\x00", "\x00\x00\xFF\x00\x00\x00\x00\xFF",
263 "\x00\x00\xFF\x00\x00\x00\xFF\x00", "\x00\x00\xFF\x00\x00\x00\xFF\xFF",
264 "\x00\x00\xFF\x00\x00\xFF\x00\x00", "\x00\x00\xFF\x00\x00\xFF\x00\xFF",
265 "\x00\x00\xFF\x00\x00\xFF\xFF\x00", "\x00\x00\xFF\x00\x00\xFF\xFF\xFF",
266 "\x00\x00\xFF\x00\xFF\x00\x00\x00", "\x00\x00\xFF\x00\xFF\x00\x00\xFF",
267 "\x00\x00\xFF\x00\xFF\x00\xFF\x00", "\x00\x00\xFF\x00\xFF\x00\xFF\xFF",
268 "\x00\x00\xFF\x00\xFF\xFF\x00\x00", "\x00\x00\xFF\x00\xFF\xFF\x00\xFF",
269 "\x00\x00\xFF\x00\xFF\xFF\xFF\x00", "\x00\x00\xFF\x00\xFF\xFF\xFF\xFF",
270 "\x00\x00\xFF\xFF\x00\x00\x00\x00", "\x00\x00\xFF\xFF\x00\x00\x00\xFF",
271 "\x00\x00\xFF\xFF\x00\x00\xFF\x00", "\x00\x00\xFF\xFF\x00\x00\xFF\xFF",
272 "\x00\x00\xFF\xFF\x00\xFF\x00\x00", "\x00\x00\xFF\xFF\x00\xFF\x00\xFF",
273 "\x00\x00\xFF\xFF\x00\xFF\xFF\x00", "\x00\x00\xFF\xFF\x00\xFF\xFF\xFF",
274 "\x00\x00\xFF\xFF\xFF\x00\x00\x00", "\x00\x00\xFF\xFF\xFF\x00\x00\xFF",
275 "\x00\x00\xFF\xFF\xFF\x00\xFF\x00", "\x00\x00\xFF\xFF\xFF\x00\xFF\xFF",
276 "\x00\x00\xFF\xFF\xFF\xFF\x00\x00", "\x00\x00\xFF\xFF\xFF\xFF\x00\xFF",
277 "\x00\x00\xFF\xFF\xFF\xFF\xFF\x00", "\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF",
278 "\x00\xFF\x00\x00\x00\x00\x00\x00", "\x00\xFF\x00\x00\x00\x00\x00\xFF",
279 "\x00\xFF\x00\x00\x00\x00\xFF\x00", "\x00\xFF\x00\x00\x00\x00\xFF\xFF",
280 "\x00\xFF\x00\x00\x00\xFF\x00\x00", "\x00\xFF\x00\x00\x00\xFF\x00\xFF",
281 "\x00\xFF\x00\x00\x00\xFF\xFF\x00", "\x00\xFF\x00\x00\x00\xFF\xFF\xFF",
282 "\x00\xFF\x00\x00\xFF\x00\x00\x00", "\x00\xFF\x00\x00\xFF\x00\x00\xFF",
283 "\x00\xFF\x00\x00\xFF\x00\xFF\x00", "\x00\xFF\x00\x00\xFF\x00\xFF\xFF",
284 "\x00\xFF\x00\x00\xFF\xFF\x00\x00", "\x00\xFF\x00\x00\xFF\xFF\x00\xFF",
285 "\x00\xFF\x00\x00\xFF\xFF\xFF\x00", "\x00\xFF\x00\x00\xFF\xFF\xFF\xFF",
286 "\x00\xFF\x00\xFF\x00\x00\x00\x00", "\x00\xFF\x00\xFF\x00\x00\x00\xFF",
287 "\x00\xFF\x00\xFF\x00\x00\xFF\x00", "\x00\xFF\x00\xFF\x00\x00\xFF\xFF",
288 "\x00\xFF\x00\xFF\x00\xFF\x00\x00", "\x00\xFF\x00\xFF\x00\xFF\x00\xFF",
289 "\x00\xFF\x00\xFF\x00\xFF\xFF\x00", "\x00\xFF\x00\xFF\x00\xFF\xFF\xFF",
290 "\x00\xFF\x00\xFF\xFF\x00\x00\x00", "\x00\xFF\x00\xFF\xFF\x00\x00\xFF",
291 "\x00\xFF\x00\xFF\xFF\x00\xFF\x00", "\x00\xFF\x00\xFF\xFF\x00\xFF\xFF",
292 "\x00\xFF\x00\xFF\xFF\xFF\x00\x00", "\x00\xFF\x00\xFF\xFF\xFF\x00\xFF",
293 "\x00\xFF\x00\xFF\xFF\xFF\xFF\x00", "\x00\xFF\x00\xFF\xFF\xFF\xFF\xFF",
294 "\x00\xFF\xFF\x00\x00\x00\x00\x00", "\x00\xFF\xFF\x00\x00\x00\x00\xFF",
295 "\x00\xFF\xFF\x00\x00\x00\xFF\x00", "\x00\xFF\xFF\x00\x00\x00\xFF\xFF",
296 "\x00\xFF\xFF\x00\x00\xFF\x00\x00", "\x00\xFF\xFF\x00\x00\xFF\x00\xFF",
297 "\x00\xFF\xFF\x00\x00\xFF\xFF\x00", "\x00\xFF\xFF\x00\x00\xFF\xFF\xFF",
298 "\x00\xFF\xFF\x00\xFF\x00\x00\x00", "\x00\xFF\xFF\x00\xFF\x00\x00\xFF",
299 "\x00\xFF\xFF\x00\xFF\x00\xFF\x00", "\x00\xFF\xFF\x00\xFF\x00\xFF\xFF",
300 "\x00\xFF\xFF\x00\xFF\xFF\x00\x00", "\x00\xFF\xFF\x00\xFF\xFF\x00\xFF",
301 "\x00\xFF\xFF\x00\xFF\xFF\xFF\x00", "\x00\xFF\xFF\x00\xFF\xFF\xFF\xFF",
302 "\x00\xFF\xFF\xFF\x00\x00\x00\x00", "\x00\xFF\xFF\xFF\x00\x00\x00\xFF",
303 "\x00\xFF\xFF\xFF\x00\x00\xFF\x00", "\x00\xFF\xFF\xFF\x00\x00\xFF\xFF",
304 "\x00\xFF\xFF\xFF\x00\xFF\x00\x00", "\x00\xFF\xFF\xFF\x00\xFF\x00\xFF",
305 "\x00\xFF\xFF\xFF\x00\xFF\xFF\x00", "\x00\xFF\xFF\xFF\x00\xFF\xFF\xFF",
306 "\x00\xFF\xFF\xFF\xFF\x00\x00\x00", "\x00\xFF\xFF\xFF\xFF\x00\x00\xFF",
307 "\x00\xFF\xFF\xFF\xFF\x00\xFF\x00", "\x00\xFF\xFF\xFF\xFF\x00\xFF\xFF",
308 "\x00\xFF\xFF\xFF\xFF\xFF\x00\x00", "\x00\xFF\xFF\xFF\xFF\xFF\x00\xFF",
309 "\x00\xFF\xFF\xFF\xFF\xFF\xFF\x00", "\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
310 "\xFF\x00\x00\x00\x00\x00\x00\x00", "\xFF\x00\x00\x00\x00\x00\x00\xFF",
311 "\xFF\x00\x00\x00\x00\x00\xFF\x00", "\xFF\x00\x00\x00\x00\x00\xFF\xFF",
312 "\xFF\x00\x00\x00\x00\xFF\x00\x00", "\xFF\x00\x00\x00\x00\xFF\x00\xFF",
313 "\xFF\x00\x00\x00\x00\xFF\xFF\x00", "\xFF\x00\x00\x00\x00\xFF\xFF\xFF",
314 "\xFF\x00\x00\x00\xFF\x00\x00\x00", "\xFF\x00\x00\x00\xFF\x00\x00\xFF",
315 "\xFF\x00\x00\x00\xFF\x00\xFF\x00", "\xFF\x00\x00\x00\xFF\x00\xFF\xFF",
316 "\xFF\x00\x00\x00\xFF\xFF\x00\x00", "\xFF\x00\x00\x00\xFF\xFF\x00\xFF",
317 "\xFF\x00\x00\x00\xFF\xFF\xFF\x00", "\xFF\x00\x00\x00\xFF\xFF\xFF\xFF",
318 "\xFF\x00\x00\xFF\x00\x00\x00\x00", "\xFF\x00\x00\xFF\x00\x00\x00\xFF",
319 "\xFF\x00\x00\xFF\x00\x00\xFF\x00", "\xFF\x00\x00\xFF\x00\x00\xFF\xFF",
320 "\xFF\x00\x00\xFF\x00\xFF\x00\x00", "\xFF\x00\x00\xFF\x00\xFF\x00\xFF",
321 "\xFF\x00\x00\xFF\x00\xFF\xFF\x00", "\xFF\x00\x00\xFF\x00\xFF\xFF\xFF",
322 "\xFF\x00\x00\xFF\xFF\x00\x00\x00", "\xFF\x00\x00\xFF\xFF\x00\x00\xFF",
323 "\xFF\x00\x00\xFF\xFF\x00\xFF\x00", "\xFF\x00\x00\xFF\xFF\x00\xFF\xFF",
324 "\xFF\x00\x00\xFF\xFF\xFF\x00\x00", "\xFF\x00\x00\xFF\xFF\xFF\x00\xFF",
325 "\xFF\x00\x00\xFF\xFF\xFF\xFF\x00", "\xFF\x00\x00\xFF\xFF\xFF\xFF\xFF",
326 "\xFF\x00\xFF\x00\x00\x00\x00\x00", "\xFF\x00\xFF\x00\x00\x00\x00\xFF",
327 "\xFF\x00\xFF\x00\x00\x00\xFF\x00", "\xFF\x00\xFF\x00\x00\x00\xFF\xFF",
328 "\xFF\x00\xFF\x00\x00\xFF\x00\x00", "\xFF\x00\xFF\x00\x00\xFF\x00\xFF",
329 "\xFF\x00\xFF\x00\x00\xFF\xFF\x00", "\xFF\x00\xFF\x00\x00\xFF\xFF\xFF",
330 "\xFF\x00\xFF\x00\xFF\x00\x00\x00", "\xFF\x00\xFF\x00\xFF\x00\x00\xFF",
331 "\xFF\x00\xFF\x00\xFF\x00\xFF\x00", "\xFF\x00\xFF\x00\xFF\x00\xFF\xFF",
332 "\xFF\x00\xFF\x00\xFF\xFF\x00\x00", "\xFF\x00\xFF\x00\xFF\xFF\x00\xFF",
333 "\xFF\x00\xFF\x00\xFF\xFF\xFF\x00", "\xFF\x00\xFF\x00\xFF\xFF\xFF\xFF",
334 "\xFF\x00\xFF\xFF\x00\x00\x00\x00", "\xFF\x00\xFF\xFF\x00\x00\x00\xFF",
335 "\xFF\x00\xFF\xFF\x00\x00\xFF\x00", "\xFF\x00\xFF\xFF\x00\x00\xFF\xFF",
336 "\xFF\x00\xFF\xFF\x00\xFF\x00\x00", "\xFF\x00\xFF\xFF\x00\xFF\x00\xFF",
337 "\xFF\x00\xFF\xFF\x00\xFF\xFF\x00", "\xFF\x00\xFF\xFF\x00\xFF\xFF\xFF",
338 "\xFF\x00\xFF\xFF\xFF\x00\x00\x00", "\xFF\x00\xFF\xFF\xFF\x00\x00\xFF",
339 "\xFF\x00\xFF\xFF\xFF\x00\xFF\x00", "\xFF\x00\xFF\xFF\xFF\x00\xFF\xFF",
340 "\xFF\x00\xFF\xFF\xFF\xFF\x00\x00", "\xFF\x00\xFF\xFF\xFF\xFF\x00\xFF",
341 "\xFF\x00\xFF\xFF\xFF\xFF\xFF\x00", "\xFF\x00\xFF\xFF\xFF\xFF\xFF\xFF",
342 "\xFF\xFF\x00\x00\x00\x00\x00\x00", "\xFF\xFF\x00\x00\x00\x00\x00\xFF",
343 "\xFF\xFF\x00\x00\x00\x00\xFF\x00", "\xFF\xFF\x00\x00\x00\x00\xFF\xFF",
344 "\xFF\xFF\x00\x00\x00\xFF\x00\x00", "\xFF\xFF\x00\x00\x00\xFF\x00\xFF",
345 "\xFF\xFF\x00\x00\x00\xFF\xFF\x00", "\xFF\xFF\x00\x00\x00\xFF\xFF\xFF",
346 "\xFF\xFF\x00\x00\xFF\x00\x00\x00", "\xFF\xFF\x00\x00\xFF\x00\x00\xFF",
347 "\xFF\xFF\x00\x00\xFF\x00\xFF\x00", "\xFF\xFF\x00\x00\xFF\x00\xFF\xFF",
348 "\xFF\xFF\x00\x00\xFF\xFF\x00\x00", "\xFF\xFF\x00\x00\xFF\xFF\x00\xFF",
349 "\xFF\xFF\x00\x00\xFF\xFF\xFF\x00", "\xFF\xFF\x00\x00\xFF\xFF\xFF\xFF",
350 "\xFF\xFF\x00\xFF\x00\x00\x00\x00", "\xFF\xFF\x00\xFF\x00\x00\x00\xFF",
351 "\xFF\xFF\x00\xFF\x00\x00\xFF\x00", "\xFF\xFF\x00\xFF\x00\x00\xFF\xFF",
352 "\xFF\xFF\x00\xFF\x00\xFF\x00\x00", "\xFF\xFF\x00\xFF\x00\xFF\x00\xFF",
353 "\xFF\xFF\x00\xFF\x00\xFF\xFF\x00", "\xFF\xFF\x00\xFF\x00\xFF\xFF\xFF",
354 "\xFF\xFF\x00\xFF\xFF\x00\x00\x00", "\xFF\xFF\x00\xFF\xFF\x00\x00\xFF",
355 "\xFF\xFF\x00\xFF\xFF\x00\xFF\x00", "\xFF\xFF\x00\xFF\xFF\x00\xFF\xFF",
356 "\xFF\xFF\x00\xFF\xFF\xFF\x00\x00", "\xFF\xFF\x00\xFF\xFF\xFF\x00\xFF",
357 "\xFF\xFF\x00\xFF\xFF\xFF\xFF\x00", "\xFF\xFF\x00\xFF\xFF\xFF\xFF\xFF",
358 "\xFF\xFF\xFF\x00\x00\x00\x00\x00", "\xFF\xFF\xFF\x00\x00\x00\x00\xFF",
359 "\xFF\xFF\xFF\x00\x00\x00\xFF\x00", "\xFF\xFF\xFF\x00\x00\x00\xFF\xFF",
360 "\xFF\xFF\xFF\x00\x00\xFF\x00\x00", "\xFF\xFF\xFF\x00\x00\xFF\x00\xFF",
361 "\xFF\xFF\xFF\x00\x00\xFF\xFF\x00", "\xFF\xFF\xFF\x00\x00\xFF\xFF\xFF",
362 "\xFF\xFF\xFF\x00\xFF\x00\x00\x00", "\xFF\xFF\xFF\x00\xFF\x00\x00\xFF",
363 "\xFF\xFF\xFF\x00\xFF\x00\xFF\x00", "\xFF\xFF\xFF\x00\xFF\x00\xFF\xFF",
364 "\xFF\xFF\xFF\x00\xFF\xFF\x00\x00", "\xFF\xFF\xFF\x00\xFF\xFF\x00\xFF",
365 "\xFF\xFF\xFF\x00\xFF\xFF\xFF\x00", "\xFF\xFF\xFF\x00\xFF\xFF\xFF\xFF",
366 "\xFF\xFF\xFF\xFF\x00\x00\x00\x00", "\xFF\xFF\xFF\xFF\x00\x00\x00\xFF",
367 "\xFF\xFF\xFF\xFF\x00\x00\xFF\x00", "\xFF\xFF\xFF\xFF\x00\x00\xFF\xFF",
368 "\xFF\xFF\xFF\xFF\x00\xFF\x00\x00", "\xFF\xFF\xFF\xFF\x00\xFF\x00\xFF",
369 "\xFF\xFF\xFF\xFF\x00\xFF\xFF\x00", "\xFF\xFF\xFF\xFF\x00\xFF\xFF\xFF",
370 "\xFF\xFF\xFF\xFF\xFF\x00\x00\x00", "\xFF\xFF\xFF\xFF\xFF\x00\x00\xFF",
371 "\xFF\xFF\xFF\xFF\xFF\x00\xFF\x00", "\xFF\xFF\xFF\xFF\xFF\x00\xFF\xFF",
372 "\xFF\xFF\xFF\xFF\xFF\xFF\x00\x00", "\xFF\xFF\xFF\xFF\xFF\xFF\x00\xFF",
373 "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00", "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
374 );
375
376 /**
377 * IP mapping helper table.
378 *
379 * Indexing this table with each source byte performs the initial bit permutation.
380 *
381 * @var Array
382 * @access private
383 */
384 var $ipmap = array(
385 0x00, 0x10, 0x01, 0x11, 0x20, 0x30, 0x21, 0x31,
386 0x02, 0x12, 0x03, 0x13, 0x22, 0x32, 0x23, 0x33,
387 0x40, 0x50, 0x41, 0x51, 0x60, 0x70, 0x61, 0x71,
388 0x42, 0x52, 0x43, 0x53, 0x62, 0x72, 0x63, 0x73,
389 0x04, 0x14, 0x05, 0x15, 0x24, 0x34, 0x25, 0x35,
390 0x06, 0x16, 0x07, 0x17, 0x26, 0x36, 0x27, 0x37,
391 0x44, 0x54, 0x45, 0x55, 0x64, 0x74, 0x65, 0x75,
392 0x46, 0x56, 0x47, 0x57, 0x66, 0x76, 0x67, 0x77,
393 0x80, 0x90, 0x81, 0x91, 0xA0, 0xB0, 0xA1, 0xB1,
394 0x82, 0x92, 0x83, 0x93, 0xA2, 0xB2, 0xA3, 0xB3,
395 0xC0, 0xD0, 0xC1, 0xD1, 0xE0, 0xF0, 0xE1, 0xF1,
396 0xC2, 0xD2, 0xC3, 0xD3, 0xE2, 0xF2, 0xE3, 0xF3,
397 0x84, 0x94, 0x85, 0x95, 0xA4, 0xB4, 0xA5, 0xB5,
398 0x86, 0x96, 0x87, 0x97, 0xA6, 0xB6, 0xA7, 0xB7,
399 0xC4, 0xD4, 0xC5, 0xD5, 0xE4, 0xF4, 0xE5, 0xF5,
400 0xC6, 0xD6, 0xC7, 0xD7, 0xE6, 0xF6, 0xE7, 0xF7,
401 0x08, 0x18, 0x09, 0x19, 0x28, 0x38, 0x29, 0x39,
402 0x0A, 0x1A, 0x0B, 0x1B, 0x2A, 0x3A, 0x2B, 0x3B,
403 0x48, 0x58, 0x49, 0x59, 0x68, 0x78, 0x69, 0x79,
404 0x4A, 0x5A, 0x4B, 0x5B, 0x6A, 0x7A, 0x6B, 0x7B,
405 0x0C, 0x1C, 0x0D, 0x1D, 0x2C, 0x3C, 0x2D, 0x3D,
406 0x0E, 0x1E, 0x0F, 0x1F, 0x2E, 0x3E, 0x2F, 0x3F,
407 0x4C, 0x5C, 0x4D, 0x5D, 0x6C, 0x7C, 0x6D, 0x7D,
408 0x4E, 0x5E, 0x4F, 0x5F, 0x6E, 0x7E, 0x6F, 0x7F,
409 0x88, 0x98, 0x89, 0x99, 0xA8, 0xB8, 0xA9, 0xB9,
410 0x8A, 0x9A, 0x8B, 0x9B, 0xAA, 0xBA, 0xAB, 0xBB,
411 0xC8, 0xD8, 0xC9, 0xD9, 0xE8, 0xF8, 0xE9, 0xF9,
412 0xCA, 0xDA, 0xCB, 0xDB, 0xEA, 0xFA, 0xEB, 0xFB,
413 0x8C, 0x9C, 0x8D, 0x9D, 0xAC, 0xBC, 0xAD, 0xBD,
414 0x8E, 0x9E, 0x8F, 0x9F, 0xAE, 0xBE, 0xAF, 0xBF,
415 0xCC, 0xDC, 0xCD, 0xDD, 0xEC, 0xFC, 0xED, 0xFD,
416 0xCE, 0xDE, 0xCF, 0xDF, 0xEE, 0xFE, 0xEF, 0xFF,
417 );
418
419 /**
420 * Inverse IP mapping helper table.
421 * Indexing this table with a byte value reverses the bit order.
422 *
423 * @var Array
424 * @access private
425 */
426 var $invipmap = array(
427 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
428 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
429 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
430 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
431 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
432 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
433 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
434 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
435 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
436 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
437 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
438 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
439 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
440 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
441 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
442 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
443 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
444 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
445 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
446 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
447 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
448 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
449 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
450 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
451 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
452 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
453 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
454 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
455 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
456 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
457 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
458 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF,
459 );
460
461 /**
462 * Pre-permuted S-box1
463 *
464 * Each box ($sbox1-$sbox8) has been vectorized, then each value pre-permuted using the
465 * P table: concatenation can then be replaced by exclusive ORs.
466 *
467 * @var Array
468 * @access private
469 */
470 var $sbox1 = array(
471 0x00808200, 0x00000000, 0x00008000, 0x00808202,
472 0x00808002, 0x00008202, 0x00000002, 0x00008000,
473 0x00000200, 0x00808200, 0x00808202, 0x00000200,
474 0x00800202, 0x00808002, 0x00800000, 0x00000002,
475 0x00000202, 0x00800200, 0x00800200, 0x00008200,
476 0x00008200, 0x00808000, 0x00808000, 0x00800202,
477 0x00008002, 0x00800002, 0x00800002, 0x00008002,
478 0x00000000, 0x00000202, 0x00008202, 0x00800000,
479 0x00008000, 0x00808202, 0x00000002, 0x00808000,
480 0x00808200, 0x00800000, 0x00800000, 0x00000200,
481 0x00808002, 0x00008000, 0x00008200, 0x00800002,
482 0x00000200, 0x00000002, 0x00800202, 0x00008202,
483 0x00808202, 0x00008002, 0x00808000, 0x00800202,
484 0x00800002, 0x00000202, 0x00008202, 0x00808200,
485 0x00000202, 0x00800200, 0x00800200, 0x00000000,
486 0x00008002, 0x00008200, 0x00000000, 0x00808002,
487 );
488
489 /**
490 * Pre-permuted S-box2
491 *
492 * @var Array
493 * @access private
494 */
495 var $sbox2 = array(
496 0x40084010, 0x40004000, 0x00004000, 0x00084010,
497 0x00080000, 0x00000010, 0x40080010, 0x40004010,
498 0x40000010, 0x40084010, 0x40084000, 0x40000000,
499 0x40004000, 0x00080000, 0x00000010, 0x40080010,
500 0x00084000, 0x00080010, 0x40004010, 0x00000000,
501 0x40000000, 0x00004000, 0x00084010, 0x40080000,
502 0x00080010, 0x40000010, 0x00000000, 0x00084000,
503 0x00004010, 0x40084000, 0x40080000, 0x00004010,
504 0x00000000, 0x00084010, 0x40080010, 0x00080000,
505 0x40004010, 0x40080000, 0x40084000, 0x00004000,
506 0x40080000, 0x40004000, 0x00000010, 0x40084010,
507 0x00084010, 0x00000010, 0x00004000, 0x40000000,
508 0x00004010, 0x40084000, 0x00080000, 0x40000010,
509 0x00080010, 0x40004010, 0x40000010, 0x00080010,
510 0x00084000, 0x00000000, 0x40004000, 0x00004010,
511 0x40000000, 0x40080010, 0x40084010, 0x00084000,
512 );
513
514 /**
515 * Pre-permuted S-box3
516 *
517 * @var Array
518 * @access private
519 */
520 var $sbox3 = array(
521 0x00000104, 0x04010100, 0x00000000, 0x04010004,
522 0x04000100, 0x00000000, 0x00010104, 0x04000100,
523 0x00010004, 0x04000004, 0x04000004, 0x00010000,
524 0x04010104, 0x00010004, 0x04010000, 0x00000104,
525 0x04000000, 0x00000004, 0x04010100, 0x00000100,
526 0x00010100, 0x04010000, 0x04010004, 0x00010104,
527 0x04000104, 0x00010100, 0x00010000, 0x04000104,
528 0x00000004, 0x04010104, 0x00000100, 0x04000000,
529 0x04010100, 0x04000000, 0x00010004, 0x00000104,
530 0x00010000, 0x04010100, 0x04000100, 0x00000000,
531 0x00000100, 0x00010004, 0x04010104, 0x04000100,
532 0x04000004, 0x00000100, 0x00000000, 0x04010004,
533 0x04000104, 0x00010000, 0x04000000, 0x04010104,
534 0x00000004, 0x00010104, 0x00010100, 0x04000004,
535 0x04010000, 0x04000104, 0x00000104, 0x04010000,
536 0x00010104, 0x00000004, 0x04010004, 0x00010100,
537 );
538
539 /**
540 * Pre-permuted S-box4
541 *
542 * @var Array
543 * @access private
544 */
545 var $sbox4 = array(
546 0x80401000, 0x80001040, 0x80001040, 0x00000040,
547 0x00401040, 0x80400040, 0x80400000, 0x80001000,
548 0x00000000, 0x00401000, 0x00401000, 0x80401040,
549 0x80000040, 0x00000000, 0x00400040, 0x80400000,
550 0x80000000, 0x00001000, 0x00400000, 0x80401000,
551 0x00000040, 0x00400000, 0x80001000, 0x00001040,
552 0x80400040, 0x80000000, 0x00001040, 0x00400040,
553 0x00001000, 0x00401040, 0x80401040, 0x80000040,
554 0x00400040, 0x80400000, 0x00401000, 0x80401040,
555 0x80000040, 0x00000000, 0x00000000, 0x00401000,
556 0x00001040, 0x00400040, 0x80400040, 0x80000000,
557 0x80401000, 0x80001040, 0x80001040, 0x00000040,
558 0x80401040, 0x80000040, 0x80000000, 0x00001000,
559 0x80400000, 0x80001000, 0x00401040, 0x80400040,
560 0x80001000, 0x00001040, 0x00400000, 0x80401000,
561 0x00000040, 0x00400000, 0x00001000, 0x00401040,
562 );
563
564 /**
565 * Pre-permuted S-box5
566 *
567 * @var Array
568 * @access private
569 */
570 var $sbox5 = array(
571 0x00000080, 0x01040080, 0x01040000, 0x21000080,
572 0x00040000, 0x00000080, 0x20000000, 0x01040000,
573 0x20040080, 0x00040000, 0x01000080, 0x20040080,
574 0x21000080, 0x21040000, 0x00040080, 0x20000000,
575 0x01000000, 0x20040000, 0x20040000, 0x00000000,
576 0x20000080, 0x21040080, 0x21040080, 0x01000080,
577 0x21040000, 0x20000080, 0x00000000, 0x21000000,
578 0x01040080, 0x01000000, 0x21000000, 0x00040080,
579 0x00040000, 0x21000080, 0x00000080, 0x01000000,
580 0x20000000, 0x01040000, 0x21000080, 0x20040080,
581 0x01000080, 0x20000000, 0x21040000, 0x01040080,
582 0x20040080, 0x00000080, 0x01000000, 0x21040000,
583 0x21040080, 0x00040080, 0x21000000, 0x21040080,
584 0x01040000, 0x00000000, 0x20040000, 0x21000000,
585 0x00040080, 0x01000080, 0x20000080, 0x00040000,
586 0x00000000, 0x20040000, 0x01040080, 0x20000080,
587 );
588
589 /**
590 * Pre-permuted S-box6
591 *
592 * @var Array
593 * @access private
594 */
595 var $sbox6 = array(
596 0x10000008, 0x10200000, 0x00002000, 0x10202008,
597 0x10200000, 0x00000008, 0x10202008, 0x00200000,
598 0x10002000, 0x00202008, 0x00200000, 0x10000008,
599 0x00200008, 0x10002000, 0x10000000, 0x00002008,
600 0x00000000, 0x00200008, 0x10002008, 0x00002000,
601 0x00202000, 0x10002008, 0x00000008, 0x10200008,
602 0x10200008, 0x00000000, 0x00202008, 0x10202000,
603 0x00002008, 0x00202000, 0x10202000, 0x10000000,
604 0x10002000, 0x00000008, 0x10200008, 0x00202000,
605 0x10202008, 0x00200000, 0x00002008, 0x10000008,
606 0x00200000, 0x10002000, 0x10000000, 0x00002008,
607 0x10000008, 0x10202008, 0x00202000, 0x10200000,
608 0x00202008, 0x10202000, 0x00000000, 0x10200008,
609 0x00000008, 0x00002000, 0x10200000, 0x00202008,
610 0x00002000, 0x00200008, 0x10002008, 0x00000000,
611 0x10202000, 0x10000000, 0x00200008, 0x10002008,
612 );
613
614 /**
615 * Pre-permuted S-box7
616 *
617 * @var Array
618 * @access private
619 */
620 var $sbox7 = array(
621 0x00100000, 0x02100001, 0x02000401, 0x00000000,
622 0x00000400, 0x02000401, 0x00100401, 0x02100400,
623 0x02100401, 0x00100000, 0x00000000, 0x02000001,
624 0x00000001, 0x02000000, 0x02100001, 0x00000401,
625 0x02000400, 0x00100401, 0x00100001, 0x02000400,
626 0x02000001, 0x02100000, 0x02100400, 0x00100001,
627 0x02100000, 0x00000400, 0x00000401, 0x02100401,
628 0x00100400, 0x00000001, 0x02000000, 0x00100400,
629 0x02000000, 0x00100400, 0x00100000, 0x02000401,
630 0x02000401, 0x02100001, 0x02100001, 0x00000001,
631 0x00100001, 0x02000000, 0x02000400, 0x00100000,
632 0x02100400, 0x00000401, 0x00100401, 0x02100400,
633 0x00000401, 0x02000001, 0x02100401, 0x02100000,
634 0x00100400, 0x00000000, 0x00000001, 0x02100401,
635 0x00000000, 0x00100401, 0x02100000, 0x00000400,
636 0x02000001, 0x02000400, 0x00000400, 0x00100001,
637 );
638
639 /**
640 * Pre-permuted S-box8
641 *
642 * @var Array
643 * @access private
644 */
645 var $sbox8 = array(
646 0x08000820, 0x00000800, 0x00020000, 0x08020820,
647 0x08000000, 0x08000820, 0x00000020, 0x08000000,
648 0x00020020, 0x08020000, 0x08020820, 0x00020800,
649 0x08020800, 0x00020820, 0x00000800, 0x00000020,
650 0x08020000, 0x08000020, 0x08000800, 0x00000820,
651 0x00020800, 0x00020020, 0x08020020, 0x08020800,
652 0x00000820, 0x00000000, 0x00000000, 0x08020020,
653 0x08000020, 0x08000800, 0x00020820, 0x00020000,
654 0x00020820, 0x00020000, 0x08020800, 0x00000800,
655 0x00000020, 0x08020020, 0x00000800, 0x00020820,
656 0x08000800, 0x00000020, 0x08000020, 0x08020000,
657 0x08020020, 0x08000000, 0x00020000, 0x08000820,
658 0x00000000, 0x08020820, 0x00020020, 0x08000020,
659 0x08020000, 0x08000800, 0x08000820, 0x00000000,
660 0x08020820, 0x00020800, 0x00020800, 0x00000820,
661 0x00000820, 0x00020020, 0x08000000, 0x08020800,
662 );
663
664 /**
665 * Sets the key.
666 *
667 * Keys can be of any length. DES, itself, uses 64-bit keys (eg. strlen($key) == 8), however, we
668 * only use the first eight, if $key has more then eight characters in it, and pad $key with the
669 * null byte if it is less then eight characters long.
670 *
671 * DES also requires that every eighth bit be a parity bit, however, we'll ignore that.
672 *
673 * If the key is not explicitly set, it'll be assumed to be all zero's.
674 *
675 * @see Crypt_Base::setKey()
676 * @access public
677 *
678 * @param String $key
679 */
680 public function setKey($key)
681 {
682 // We check/cut here only up to max length of the key.
683 // Key padding to the proper length will be done in _setupKey()
684 if (strlen($key) > $this->key_size_max) {
685 $key = substr($key, 0, $this->key_size_max);
686 }
687
688 // Sets the key
689 parent::setKey($key);
690 }
691
692 /**
693 * Encrypts a block
694 *
695 * @see Crypt_Base::_encryptBlock()
696 * @see Crypt_Base::encrypt()
697 * @see Crypt_DES::encrypt()
698 * @access private
699 *
700 * @param String $in
701 *
702 * @return String
703 */
704 public function _encryptBlock($in)
705 {
706 return $this->_processBlock($in, CRYPT_DES_ENCRYPT);
707 }
708
709 /**
710 * Decrypts a block
711 *
712 * @see Crypt_Base::_decryptBlock()
713 * @see Crypt_Base::decrypt()
714 * @see Crypt_DES::decrypt()
715 * @access private
716 *
717 * @param String $in
718 *
719 * @return String
720 */
721 public function _decryptBlock($in)
722 {
723 return $this->_processBlock($in, CRYPT_DES_DECRYPT);
724 }
725
726 /**
727 * Encrypts or decrypts a 64-bit block
728 *
729 * $mode should be either CRYPT_DES_ENCRYPT or CRYPT_DES_DECRYPT. See
730 * {@link http://en.wikipedia.org/wiki/Image:Feistel.png Feistel.png} to get a general
731 * idea of what this function does.
732 *
733 * @see Crypt_DES::_encryptBlock()
734 * @see Crypt_DES::_decryptBlock()
735 * @access private
736 *
737 * @param String $block
738 * @param Integer $mode
739 *
740 * @return String
741 */
742 public function _processBlock($block, $mode)
743 {
744 static $sbox1, $sbox2, $sbox3, $sbox4, $sbox5, $sbox6, $sbox7, $sbox8, $shuffleip, $shuffleinvip;
745 if (!$sbox1) {
746 $sbox1 = array_map("intval", $this->sbox1);
747 $sbox2 = array_map("intval", $this->sbox2);
748 $sbox3 = array_map("intval", $this->sbox3);
749 $sbox4 = array_map("intval", $this->sbox4);
750 $sbox5 = array_map("intval", $this->sbox5);
751 $sbox6 = array_map("intval", $this->sbox6);
752 $sbox7 = array_map("intval", $this->sbox7);
753 $sbox8 = array_map("intval", $this->sbox8);
754 /* Merge $shuffle with $[inv]ipmap */
755 for ($i = 0; $i < 256; ++$i) {
756 $shuffleip[] = $this->shuffle[$this->ipmap[$i]];
757 $shuffleinvip[] = $this->shuffle[$this->invipmap[$i]];
758 }
759 }
760
761 $keys = $this->keys[$mode];
762 $ki = -1;
763
764 // Do the initial IP permutation.
765 $t = unpack('Nl/Nr', $block);
766 list($l, $r) = array($t['l'], $t['r']);
767 $block = ($shuffleip[$r & 0xFF] & "\x80\x80\x80\x80\x80\x80\x80\x80") | // This code handles data encryption used by ManageWP and is not a security issue.
768 ($shuffleip[($r >> 8) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
769 ($shuffleip[($r >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
770 ($shuffleip[($r >> 24) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
771 ($shuffleip[$l & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
772 ($shuffleip[($l >> 8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
773 ($shuffleip[($l >> 16) & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
774 ($shuffleip[($l >> 24) & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
775
776 // Extract L0 and R0.
777 $t = unpack('Nl/Nr', $block);
778 list($l, $r) = array($t['l'], $t['r']);
779
780 for ($des_round = 0; $des_round < $this->des_rounds; ++$des_round) {
781 // Perform the 16 steps.
782 for ($i = 0; $i < 16; $i++) {
783 // start of "the Feistel (F) function" - see the following URL:
784 // http://en.wikipedia.org/wiki/Image:Data_Encryption_Standard_InfoBox_Diagram.png
785 // Merge key schedule.
786 $b1 = (($r >> 3) & 0x1FFFFFFF) ^ ($r << 29) ^ $keys[++$ki];
787 $b2 = (($r >> 31) & 0x00000001) ^ ($r << 1) ^ $keys[++$ki];
788
789 // S-box indexing.
790 $t = $sbox1[($b1 >> 24) & 0x3F] ^ $sbox2[($b2 >> 24) & 0x3F] ^
791 $sbox3[($b1 >> 16) & 0x3F] ^ $sbox4[($b2 >> 16) & 0x3F] ^
792 $sbox5[($b1 >> 8) & 0x3F] ^ $sbox6[($b2 >> 8) & 0x3F] ^
793 $sbox7[$b1 & 0x3F] ^ $sbox8[$b2 & 0x3F] ^ $l;
794 // end of "the Feistel (F) function"
795
796 $l = $r;
797 $r = $t;
798 }
799
800 // Last step should not permute L & R.
801 $t = $l;
802 $l = $r;
803 $r = $t;
804 }
805
806 // Perform the inverse IP permutation.
807 return ($shuffleinvip[($r >> 24) & 0xFF] & "\x80\x80\x80\x80\x80\x80\x80\x80") | // This code handles data encryption used by ManageWP and is not a security issue.
808 ($shuffleinvip[($l >> 24) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
809 ($shuffleinvip[($r >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
810 ($shuffleinvip[($l >> 16) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
811 ($shuffleinvip[($r >> 8) & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
812 ($shuffleinvip[($l >> 8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
813 ($shuffleinvip[$r & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
814 ($shuffleinvip[$l & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
815 }
816
817 /**
818 * Creates the key schedule
819 *
820 * @see Crypt_Base::_setupKey()
821 * @access private
822 */
823 public function _setupKey()
824 {
825 if (isset($this->kl['key']) && $this->key === $this->kl['key'] && $this->des_rounds === $this->kl['des_rounds']) {
826 // already expanded
827 return;
828 }
829 $this->kl = array('key' => $this->key, 'des_rounds' => $this->des_rounds);
830
831 static $shifts = array( // number of key bits shifted per round
832 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1,
833 );
834
835 static $pc1map = array(
836 0x00, 0x00, 0x08, 0x08, 0x04, 0x04, 0x0C, 0x0C,
837 0x02, 0x02, 0x0A, 0x0A, 0x06, 0x06, 0x0E, 0x0E,
838 0x10, 0x10, 0x18, 0x18, 0x14, 0x14, 0x1C, 0x1C,
839 0x12, 0x12, 0x1A, 0x1A, 0x16, 0x16, 0x1E, 0x1E,
840 0x20, 0x20, 0x28, 0x28, 0x24, 0x24, 0x2C, 0x2C,
841 0x22, 0x22, 0x2A, 0x2A, 0x26, 0x26, 0x2E, 0x2E,
842 0x30, 0x30, 0x38, 0x38, 0x34, 0x34, 0x3C, 0x3C,
843 0x32, 0x32, 0x3A, 0x3A, 0x36, 0x36, 0x3E, 0x3E,
844 0x40, 0x40, 0x48, 0x48, 0x44, 0x44, 0x4C, 0x4C,
845 0x42, 0x42, 0x4A, 0x4A, 0x46, 0x46, 0x4E, 0x4E,
846 0x50, 0x50, 0x58, 0x58, 0x54, 0x54, 0x5C, 0x5C,
847 0x52, 0x52, 0x5A, 0x5A, 0x56, 0x56, 0x5E, 0x5E,
848 0x60, 0x60, 0x68, 0x68, 0x64, 0x64, 0x6C, 0x6C,
849 0x62, 0x62, 0x6A, 0x6A, 0x66, 0x66, 0x6E, 0x6E,
850 0x70, 0x70, 0x78, 0x78, 0x74, 0x74, 0x7C, 0x7C,
851 0x72, 0x72, 0x7A, 0x7A, 0x76, 0x76, 0x7E, 0x7E,
852 0x80, 0x80, 0x88, 0x88, 0x84, 0x84, 0x8C, 0x8C,
853 0x82, 0x82, 0x8A, 0x8A, 0x86, 0x86, 0x8E, 0x8E,
854 0x90, 0x90, 0x98, 0x98, 0x94, 0x94, 0x9C, 0x9C,
855 0x92, 0x92, 0x9A, 0x9A, 0x96, 0x96, 0x9E, 0x9E,
856 0xA0, 0xA0, 0xA8, 0xA8, 0xA4, 0xA4, 0xAC, 0xAC,
857 0xA2, 0xA2, 0xAA, 0xAA, 0xA6, 0xA6, 0xAE, 0xAE,
858 0xB0, 0xB0, 0xB8, 0xB8, 0xB4, 0xB4, 0xBC, 0xBC,
859 0xB2, 0xB2, 0xBA, 0xBA, 0xB6, 0xB6, 0xBE, 0xBE,
860 0xC0, 0xC0, 0xC8, 0xC8, 0xC4, 0xC4, 0xCC, 0xCC,
861 0xC2, 0xC2, 0xCA, 0xCA, 0xC6, 0xC6, 0xCE, 0xCE,
862 0xD0, 0xD0, 0xD8, 0xD8, 0xD4, 0xD4, 0xDC, 0xDC,
863 0xD2, 0xD2, 0xDA, 0xDA, 0xD6, 0xD6, 0xDE, 0xDE,
864 0xE0, 0xE0, 0xE8, 0xE8, 0xE4, 0xE4, 0xEC, 0xEC,
865 0xE2, 0xE2, 0xEA, 0xEA, 0xE6, 0xE6, 0xEE, 0xEE,
866 0xF0, 0xF0, 0xF8, 0xF8, 0xF4, 0xF4, 0xFC, 0xFC,
867 0xF2, 0xF2, 0xFA, 0xFA, 0xF6, 0xF6, 0xFE, 0xFE,
868 );
869
870 // Mapping tables for the PC-2 transformation.
871 static $pc2mapc1 = array(
872 0x00000000, 0x00000400, 0x00200000, 0x00200400,
873 0x00000001, 0x00000401, 0x00200001, 0x00200401,
874 0x02000000, 0x02000400, 0x02200000, 0x02200400,
875 0x02000001, 0x02000401, 0x02200001, 0x02200401,
876 );
877 static $pc2mapc2 = array(
878 0x00000000, 0x00000800, 0x08000000, 0x08000800,
879 0x00010000, 0x00010800, 0x08010000, 0x08010800,
880 0x00000000, 0x00000800, 0x08000000, 0x08000800,
881 0x00010000, 0x00010800, 0x08010000, 0x08010800,
882 0x00000100, 0x00000900, 0x08000100, 0x08000900,
883 0x00010100, 0x00010900, 0x08010100, 0x08010900,
884 0x00000100, 0x00000900, 0x08000100, 0x08000900,
885 0x00010100, 0x00010900, 0x08010100, 0x08010900,
886 0x00000010, 0x00000810, 0x08000010, 0x08000810,
887 0x00010010, 0x00010810, 0x08010010, 0x08010810,
888 0x00000010, 0x00000810, 0x08000010, 0x08000810,
889 0x00010010, 0x00010810, 0x08010010, 0x08010810,
890 0x00000110, 0x00000910, 0x08000110, 0x08000910,
891 0x00010110, 0x00010910, 0x08010110, 0x08010910,
892 0x00000110, 0x00000910, 0x08000110, 0x08000910,
893 0x00010110, 0x00010910, 0x08010110, 0x08010910,
894 0x00040000, 0x00040800, 0x08040000, 0x08040800,
895 0x00050000, 0x00050800, 0x08050000, 0x08050800,
896 0x00040000, 0x00040800, 0x08040000, 0x08040800,
897 0x00050000, 0x00050800, 0x08050000, 0x08050800,
898 0x00040100, 0x00040900, 0x08040100, 0x08040900,
899 0x00050100, 0x00050900, 0x08050100, 0x08050900,
900 0x00040100, 0x00040900, 0x08040100, 0x08040900,
901 0x00050100, 0x00050900, 0x08050100, 0x08050900,
902 0x00040010, 0x00040810, 0x08040010, 0x08040810,
903 0x00050010, 0x00050810, 0x08050010, 0x08050810,
904 0x00040010, 0x00040810, 0x08040010, 0x08040810,
905 0x00050010, 0x00050810, 0x08050010, 0x08050810,
906 0x00040110, 0x00040910, 0x08040110, 0x08040910,
907 0x00050110, 0x00050910, 0x08050110, 0x08050910,
908 0x00040110, 0x00040910, 0x08040110, 0x08040910,
909 0x00050110, 0x00050910, 0x08050110, 0x08050910,
910 0x01000000, 0x01000800, 0x09000000, 0x09000800,
911 0x01010000, 0x01010800, 0x09010000, 0x09010800,
912 0x01000000, 0x01000800, 0x09000000, 0x09000800,
913 0x01010000, 0x01010800, 0x09010000, 0x09010800,
914 0x01000100, 0x01000900, 0x09000100, 0x09000900,
915 0x01010100, 0x01010900, 0x09010100, 0x09010900,
916 0x01000100, 0x01000900, 0x09000100, 0x09000900,
917 0x01010100, 0x01010900, 0x09010100, 0x09010900,
918 0x01000010, 0x01000810, 0x09000010, 0x09000810,
919 0x01010010, 0x01010810, 0x09010010, 0x09010810,
920 0x01000010, 0x01000810, 0x09000010, 0x09000810,
921 0x01010010, 0x01010810, 0x09010010, 0x09010810,
922 0x01000110, 0x01000910, 0x09000110, 0x09000910,
923 0x01010110, 0x01010910, 0x09010110, 0x09010910,
924 0x01000110, 0x01000910, 0x09000110, 0x09000910,
925 0x01010110, 0x01010910, 0x09010110, 0x09010910,
926 0x01040000, 0x01040800, 0x09040000, 0x09040800,
927 0x01050000, 0x01050800, 0x09050000, 0x09050800,
928 0x01040000, 0x01040800, 0x09040000, 0x09040800,
929 0x01050000, 0x01050800, 0x09050000, 0x09050800,
930 0x01040100, 0x01040900, 0x09040100, 0x09040900,
931 0x01050100, 0x01050900, 0x09050100, 0x09050900,
932 0x01040100, 0x01040900, 0x09040100, 0x09040900,
933 0x01050100, 0x01050900, 0x09050100, 0x09050900,
934 0x01040010, 0x01040810, 0x09040010, 0x09040810,
935 0x01050010, 0x01050810, 0x09050010, 0x09050810,
936 0x01040010, 0x01040810, 0x09040010, 0x09040810,
937 0x01050010, 0x01050810, 0x09050010, 0x09050810,
938 0x01040110, 0x01040910, 0x09040110, 0x09040910,
939 0x01050110, 0x01050910, 0x09050110, 0x09050910,
940 0x01040110, 0x01040910, 0x09040110, 0x09040910,
941 0x01050110, 0x01050910, 0x09050110, 0x09050910,
942 );
943 static $pc2mapc3 = array(
944 0x00000000, 0x00000004, 0x00001000, 0x00001004,
945 0x00000000, 0x00000004, 0x00001000, 0x00001004,
946 0x10000000, 0x10000004, 0x10001000, 0x10001004,
947 0x10000000, 0x10000004, 0x10001000, 0x10001004,
948 0x00000020, 0x00000024, 0x00001020, 0x00001024,
949 0x00000020, 0x00000024, 0x00001020, 0x00001024,
950 0x10000020, 0x10000024, 0x10001020, 0x10001024,
951 0x10000020, 0x10000024, 0x10001020, 0x10001024,
952 0x00080000, 0x00080004, 0x00081000, 0x00081004,
953 0x00080000, 0x00080004, 0x00081000, 0x00081004,
954 0x10080000, 0x10080004, 0x10081000, 0x10081004,
955 0x10080000, 0x10080004, 0x10081000, 0x10081004,
956 0x00080020, 0x00080024, 0x00081020, 0x00081024,
957 0x00080020, 0x00080024, 0x00081020, 0x00081024,
958 0x10080020, 0x10080024, 0x10081020, 0x10081024,
959 0x10080020, 0x10080024, 0x10081020, 0x10081024,
960 0x20000000, 0x20000004, 0x20001000, 0x20001004,
961 0x20000000, 0x20000004, 0x20001000, 0x20001004,
962 0x30000000, 0x30000004, 0x30001000, 0x30001004,
963 0x30000000, 0x30000004, 0x30001000, 0x30001004,
964 0x20000020, 0x20000024, 0x20001020, 0x20001024,
965 0x20000020, 0x20000024, 0x20001020, 0x20001024,
966 0x30000020, 0x30000024, 0x30001020, 0x30001024,
967 0x30000020, 0x30000024, 0x30001020, 0x30001024,
968 0x20080000, 0x20080004, 0x20081000, 0x20081004,
969 0x20080000, 0x20080004, 0x20081000, 0x20081004,
970 0x30080000, 0x30080004, 0x30081000, 0x30081004,
971 0x30080000, 0x30080004, 0x30081000, 0x30081004,
972 0x20080020, 0x20080024, 0x20081020, 0x20081024,
973 0x20080020, 0x20080024, 0x20081020, 0x20081024,
974 0x30080020, 0x30080024, 0x30081020, 0x30081024,
975 0x30080020, 0x30080024, 0x30081020, 0x30081024,
976 0x00000002, 0x00000006, 0x00001002, 0x00001006,
977 0x00000002, 0x00000006, 0x00001002, 0x00001006,
978 0x10000002, 0x10000006, 0x10001002, 0x10001006,
979 0x10000002, 0x10000006, 0x10001002, 0x10001006,
980 0x00000022, 0x00000026, 0x00001022, 0x00001026,
981 0x00000022, 0x00000026, 0x00001022, 0x00001026,
982 0x10000022, 0x10000026, 0x10001022, 0x10001026,
983 0x10000022, 0x10000026, 0x10001022, 0x10001026,
984 0x00080002, 0x00080006, 0x00081002, 0x00081006,
985 0x00080002, 0x00080006, 0x00081002, 0x00081006,
986 0x10080002, 0x10080006, 0x10081002, 0x10081006,
987 0x10080002, 0x10080006, 0x10081002, 0x10081006,
988 0x00080022, 0x00080026, 0x00081022, 0x00081026,
989 0x00080022, 0x00080026, 0x00081022, 0x00081026,
990 0x10080022, 0x10080026, 0x10081022, 0x10081026,
991 0x10080022, 0x10080026, 0x10081022, 0x10081026,
992 0x20000002, 0x20000006, 0x20001002, 0x20001006,
993 0x20000002, 0x20000006, 0x20001002, 0x20001006,
994 0x30000002, 0x30000006, 0x30001002, 0x30001006,
995 0x30000002, 0x30000006, 0x30001002, 0x30001006,
996 0x20000022, 0x20000026, 0x20001022, 0x20001026,
997 0x20000022, 0x20000026, 0x20001022, 0x20001026,
998 0x30000022, 0x30000026, 0x30001022, 0x30001026,
999 0x30000022, 0x30000026, 0x30001022, 0x30001026,
1000 0x20080002, 0x20080006, 0x20081002, 0x20081006,
1001 0x20080002, 0x20080006, 0x20081002, 0x20081006,
1002 0x30080002, 0x30080006, 0x30081002, 0x30081006,
1003 0x30080002, 0x30080006, 0x30081002, 0x30081006,
1004 0x20080022, 0x20080026, 0x20081022, 0x20081026,
1005 0x20080022, 0x20080026, 0x20081022, 0x20081026,
1006 0x30080022, 0x30080026, 0x30081022, 0x30081026,
1007 0x30080022, 0x30080026, 0x30081022, 0x30081026,
1008 );
1009 static $pc2mapc4 = array(
1010 0x00000000, 0x00100000, 0x00000008, 0x00100008,
1011 0x00000200, 0x00100200, 0x00000208, 0x00100208,
1012 0x00000000, 0x00100000, 0x00000008, 0x00100008,
1013 0x00000200, 0x00100200, 0x00000208, 0x00100208,
1014 0x04000000, 0x04100000, 0x04000008, 0x04100008,
1015 0x04000200, 0x04100200, 0x04000208, 0x04100208,
1016 0x04000000, 0x04100000, 0x04000008, 0x04100008,
1017 0x04000200, 0x04100200, 0x04000208, 0x04100208,
1018 0x00002000, 0x00102000, 0x00002008, 0x00102008,
1019 0x00002200, 0x00102200, 0x00002208, 0x00102208,
1020 0x00002000, 0x00102000, 0x00002008, 0x00102008,
1021 0x00002200, 0x00102200, 0x00002208, 0x00102208,
1022 0x04002000, 0x04102000, 0x04002008, 0x04102008,
1023 0x04002200, 0x04102200, 0x04002208, 0x04102208,
1024 0x04002000, 0x04102000, 0x04002008, 0x04102008,
1025 0x04002200, 0x04102200, 0x04002208, 0x04102208,
1026 0x00000000, 0x00100000, 0x00000008, 0x00100008,
1027 0x00000200, 0x00100200, 0x00000208, 0x00100208,
1028 0x00000000, 0x00100000, 0x00000008, 0x00100008,
1029 0x00000200, 0x00100200, 0x00000208, 0x00100208,
1030 0x04000000, 0x04100000, 0x04000008, 0x04100008,
1031 0x04000200, 0x04100200, 0x04000208, 0x04100208,
1032 0x04000000, 0x04100000, 0x04000008, 0x04100008,
1033 0x04000200, 0x04100200, 0x04000208, 0x04100208,
1034 0x00002000, 0x00102000, 0x00002008, 0x00102008,
1035 0x00002200, 0x00102200, 0x00002208, 0x00102208,
1036 0x00002000, 0x00102000, 0x00002008, 0x00102008,
1037 0x00002200, 0x00102200, 0x00002208, 0x00102208,
1038 0x04002000, 0x04102000, 0x04002008, 0x04102008,
1039 0x04002200, 0x04102200, 0x04002208, 0x04102208,
1040 0x04002000, 0x04102000, 0x04002008, 0x04102008,
1041 0x04002200, 0x04102200, 0x04002208, 0x04102208,
1042 0x00020000, 0x00120000, 0x00020008, 0x00120008,
1043 0x00020200, 0x00120200, 0x00020208, 0x00120208,
1044 0x00020000, 0x00120000, 0x00020008, 0x00120008,
1045 0x00020200, 0x00120200, 0x00020208, 0x00120208,
1046 0x04020000, 0x04120000, 0x04020008, 0x04120008,
1047 0x04020200, 0x04120200, 0x04020208, 0x04120208,
1048 0x04020000, 0x04120000, 0x04020008, 0x04120008,
1049 0x04020200, 0x04120200, 0x04020208, 0x04120208,
1050 0x00022000, 0x00122000, 0x00022008, 0x00122008,
1051 0x00022200, 0x00122200, 0x00022208, 0x00122208,
1052 0x00022000, 0x00122000, 0x00022008, 0x00122008,
1053 0x00022200, 0x00122200, 0x00022208, 0x00122208,
1054 0x04022000, 0x04122000, 0x04022008, 0x04122008,
1055 0x04022200, 0x04122200, 0x04022208, 0x04122208,
1056 0x04022000, 0x04122000, 0x04022008, 0x04122008,
1057 0x04022200, 0x04122200, 0x04022208, 0x04122208,
1058 0x00020000, 0x00120000, 0x00020008, 0x00120008,
1059 0x00020200, 0x00120200, 0x00020208, 0x00120208,
1060 0x00020000, 0x00120000, 0x00020008, 0x00120008,
1061 0x00020200, 0x00120200, 0x00020208, 0x00120208,
1062 0x04020000, 0x04120000, 0x04020008, 0x04120008,
1063 0x04020200, 0x04120200, 0x04020208, 0x04120208,
1064 0x04020000, 0x04120000, 0x04020008, 0x04120008,
1065 0x04020200, 0x04120200, 0x04020208, 0x04120208,
1066 0x00022000, 0x00122000, 0x00022008, 0x00122008,
1067 0x00022200, 0x00122200, 0x00022208, 0x00122208,
1068 0x00022000, 0x00122000, 0x00022008, 0x00122008,
1069 0x00022200, 0x00122200, 0x00022208, 0x00122208,
1070 0x04022000, 0x04122000, 0x04022008, 0x04122008,
1071 0x04022200, 0x04122200, 0x04022208, 0x04122208,
1072 0x04022000, 0x04122000, 0x04022008, 0x04122008,
1073 0x04022200, 0x04122200, 0x04022208, 0x04122208,
1074 );
1075 static $pc2mapd1 = array(
1076 0x00000000, 0x00000001, 0x08000000, 0x08000001,
1077 0x00200000, 0x00200001, 0x08200000, 0x08200001,
1078 0x00000002, 0x00000003, 0x08000002, 0x08000003,
1079 0x00200002, 0x00200003, 0x08200002, 0x08200003,
1080 );
1081 static $pc2mapd2 = array(
1082 0x00000000, 0x00100000, 0x00000800, 0x00100800,
1083 0x00000000, 0x00100000, 0x00000800, 0x00100800,
1084 0x04000000, 0x04100000, 0x04000800, 0x04100800,
1085 0x04000000, 0x04100000, 0x04000800, 0x04100800,
1086 0x00000004, 0x00100004, 0x00000804, 0x00100804,
1087 0x00000004, 0x00100004, 0x00000804, 0x00100804,
1088 0x04000004, 0x04100004, 0x04000804, 0x04100804,
1089 0x04000004, 0x04100004, 0x04000804, 0x04100804,
1090 0x00000000, 0x00100000, 0x00000800, 0x00100800,
1091 0x00000000, 0x00100000, 0x00000800, 0x00100800,
1092 0x04000000, 0x04100000, 0x04000800, 0x04100800,
1093 0x04000000, 0x04100000, 0x04000800, 0x04100800,
1094 0x00000004, 0x00100004, 0x00000804, 0x00100804,
1095 0x00000004, 0x00100004, 0x00000804, 0x00100804,
1096 0x04000004, 0x04100004, 0x04000804, 0x04100804,
1097 0x04000004, 0x04100004, 0x04000804, 0x04100804,
1098 0x00000200, 0x00100200, 0x00000A00, 0x00100A00,
1099 0x00000200, 0x00100200, 0x00000A00, 0x00100A00,
1100 0x04000200, 0x04100200, 0x04000A00, 0x04100A00,
1101 0x04000200, 0x04100200, 0x04000A00, 0x04100A00,
1102 0x00000204, 0x00100204, 0x00000A04, 0x00100A04,
1103 0x00000204, 0x00100204, 0x00000A04, 0x00100A04,
1104 0x04000204, 0x04100204, 0x04000A04, 0x04100A04,
1105 0x04000204, 0x04100204, 0x04000A04, 0x04100A04,
1106 0x00000200, 0x00100200, 0x00000A00, 0x00100A00,
1107 0x00000200, 0x00100200, 0x00000A00, 0x00100A00,
1108 0x04000200, 0x04100200, 0x04000A00, 0x04100A00,
1109 0x04000200, 0x04100200, 0x04000A00, 0x04100A00,
1110 0x00000204, 0x00100204, 0x00000A04, 0x00100A04,
1111 0x00000204, 0x00100204, 0x00000A04, 0x00100A04,
1112 0x04000204, 0x04100204, 0x04000A04, 0x04100A04,
1113 0x04000204, 0x04100204, 0x04000A04, 0x04100A04,
1114 0x00020000, 0x00120000, 0x00020800, 0x00120800,
1115 0x00020000, 0x00120000, 0x00020800, 0x00120800,
1116 0x04020000, 0x04120000, 0x04020800, 0x04120800,
1117 0x04020000, 0x04120000, 0x04020800, 0x04120800,
1118 0x00020004, 0x00120004, 0x00020804, 0x00120804,
1119 0x00020004, 0x00120004, 0x00020804, 0x00120804,
1120 0x04020004, 0x04120004, 0x04020804, 0x04120804,
1121 0x04020004, 0x04120004, 0x04020804, 0x04120804,
1122 0x00020000, 0x00120000, 0x00020800, 0x00120800,
1123 0x00020000, 0x00120000, 0x00020800, 0x00120800,
1124 0x04020000, 0x04120000, 0x04020800, 0x04120800,
1125 0x04020000, 0x04120000, 0x04020800, 0x04120800,
1126 0x00020004, 0x00120004, 0x00020804, 0x00120804,
1127 0x00020004, 0x00120004, 0x00020804, 0x00120804,
1128 0x04020004, 0x04120004, 0x04020804, 0x04120804,
1129 0x04020004, 0x04120004, 0x04020804, 0x04120804,
1130 0x00020200, 0x00120200, 0x00020A00, 0x00120A00,
1131 0x00020200, 0x00120200, 0x00020A00, 0x00120A00,
1132 0x04020200, 0x04120200, 0x04020A00, 0x04120A00,
1133 0x04020200, 0x04120200, 0x04020A00, 0x04120A00,
1134 0x00020204, 0x00120204, 0x00020A04, 0x00120A04,
1135 0x00020204, 0x00120204, 0x00020A04, 0x00120A04,
1136 0x04020204, 0x04120204, 0x04020A04, 0x04120A04,
1137 0x04020204, 0x04120204, 0x04020A04, 0x04120A04,
1138 0x00020200, 0x00120200, 0x00020A00, 0x00120A00,
1139 0x00020200, 0x00120200, 0x00020A00, 0x00120A00,
1140 0x04020200, 0x04120200, 0x04020A00, 0x04120A00,
1141 0x04020200, 0x04120200, 0x04020A00, 0x04120A00,
1142 0x00020204, 0x00120204, 0x00020A04, 0x00120A04,
1143 0x00020204, 0x00120204, 0x00020A04, 0x00120A04,
1144 0x04020204, 0x04120204, 0x04020A04, 0x04120A04,
1145 0x04020204, 0x04120204, 0x04020A04, 0x04120A04,
1146 );
1147 static $pc2mapd3 = array(
1148 0x00000000, 0x00010000, 0x02000000, 0x02010000,
1149 0x00000020, 0x00010020, 0x02000020, 0x02010020,
1150 0x00040000, 0x00050000, 0x02040000, 0x02050000,
1151 0x00040020, 0x00050020, 0x02040020, 0x02050020,
1152 0x00002000, 0x00012000, 0x02002000, 0x02012000,
1153 0x00002020, 0x00012020, 0x02002020, 0x02012020,
1154 0x00042000, 0x00052000, 0x02042000, 0x02052000,
1155 0x00042020, 0x00052020, 0x02042020, 0x02052020,
1156 0x00000000, 0x00010000, 0x02000000, 0x02010000,
1157 0x00000020, 0x00010020, 0x02000020, 0x02010020,
1158 0x00040000, 0x00050000, 0x02040000, 0x02050000,
1159 0x00040020, 0x00050020, 0x02040020, 0x02050020,
1160 0x00002000, 0x00012000, 0x02002000, 0x02012000,
1161 0x00002020, 0x00012020, 0x02002020, 0x02012020,
1162 0x00042000, 0x00052000, 0x02042000, 0x02052000,
1163 0x00042020, 0x00052020, 0x02042020, 0x02052020,
1164 0x00000010, 0x00010010, 0x02000010, 0x02010010,
1165 0x00000030, 0x00010030, 0x02000030, 0x02010030,
1166 0x00040010, 0x00050010, 0x02040010, 0x02050010,
1167 0x00040030, 0x00050030, 0x02040030, 0x02050030,
1168 0x00002010, 0x00012010, 0x02002010, 0x02012010,
1169 0x00002030, 0x00012030, 0x02002030, 0x02012030,
1170 0x00042010, 0x00052010, 0x02042010, 0x02052010,
1171 0x00042030, 0x00052030, 0x02042030, 0x02052030,
1172 0x00000010, 0x00010010, 0x02000010, 0x02010010,
1173 0x00000030, 0x00010030, 0x02000030, 0x02010030,
1174 0x00040010, 0x00050010, 0x02040010, 0x02050010,
1175 0x00040030, 0x00050030, 0x02040030, 0x02050030,
1176 0x00002010, 0x00012010, 0x02002010, 0x02012010,
1177 0x00002030, 0x00012030, 0x02002030, 0x02012030,
1178 0x00042010, 0x00052010, 0x02042010, 0x02052010,
1179 0x00042030, 0x00052030, 0x02042030, 0x02052030,
1180 0x20000000, 0x20010000, 0x22000000, 0x22010000,
1181 0x20000020, 0x20010020, 0x22000020, 0x22010020,
1182 0x20040000, 0x20050000, 0x22040000, 0x22050000,
1183 0x20040020, 0x20050020, 0x22040020, 0x22050020,
1184 0x20002000, 0x20012000, 0x22002000, 0x22012000,
1185 0x20002020, 0x20012020, 0x22002020, 0x22012020,
1186 0x20042000, 0x20052000, 0x22042000, 0x22052000,
1187 0x20042020, 0x20052020, 0x22042020, 0x22052020,
1188 0x20000000, 0x20010000, 0x22000000, 0x22010000,
1189 0x20000020, 0x20010020, 0x22000020, 0x22010020,
1190 0x20040000, 0x20050000, 0x22040000, 0x22050000,
1191 0x20040020, 0x20050020, 0x22040020, 0x22050020,
1192 0x20002000, 0x20012000, 0x22002000, 0x22012000,
1193 0x20002020, 0x20012020, 0x22002020, 0x22012020,
1194 0x20042000, 0x20052000, 0x22042000, 0x22052000,
1195 0x20042020, 0x20052020, 0x22042020, 0x22052020,
1196 0x20000010, 0x20010010, 0x22000010, 0x22010010,
1197 0x20000030, 0x20010030, 0x22000030, 0x22010030,
1198 0x20040010, 0x20050010, 0x22040010, 0x22050010,
1199 0x20040030, 0x20050030, 0x22040030, 0x22050030,
1200 0x20002010, 0x20012010, 0x22002010, 0x22012010,
1201 0x20002030, 0x20012030, 0x22002030, 0x22012030,
1202 0x20042010, 0x20052010, 0x22042010, 0x22052010,
1203 0x20042030, 0x20052030, 0x22042030, 0x22052030,
1204 0x20000010, 0x20010010, 0x22000010, 0x22010010,
1205 0x20000030, 0x20010030, 0x22000030, 0x22010030,
1206 0x20040010, 0x20050010, 0x22040010, 0x22050010,
1207 0x20040030, 0x20050030, 0x22040030, 0x22050030,
1208 0x20002010, 0x20012010, 0x22002010, 0x22012010,
1209 0x20002030, 0x20012030, 0x22002030, 0x22012030,
1210 0x20042010, 0x20052010, 0x22042010, 0x22052010,
1211 0x20042030, 0x20052030, 0x22042030, 0x22052030,
1212 );
1213 static $pc2mapd4 = array(
1214 0x00000000, 0x00000400, 0x01000000, 0x01000400,
1215 0x00000000, 0x00000400, 0x01000000, 0x01000400,
1216 0x00000100, 0x00000500, 0x01000100, 0x01000500,
1217 0x00000100, 0x00000500, 0x01000100, 0x01000500,
1218 0x10000000, 0x10000400, 0x11000000, 0x11000400,
1219 0x10000000, 0x10000400, 0x11000000, 0x11000400,
1220 0x10000100, 0x10000500, 0x11000100, 0x11000500,
1221 0x10000100, 0x10000500, 0x11000100, 0x11000500,
1222 0x00080000, 0x00080400, 0x01080000, 0x01080400,
1223 0x00080000, 0x00080400, 0x01080000, 0x01080400,
1224 0x00080100, 0x00080500, 0x01080100, 0x01080500,
1225 0x00080100, 0x00080500, 0x01080100, 0x01080500,
1226 0x10080000, 0x10080400, 0x11080000, 0x11080400,
1227 0x10080000, 0x10080400, 0x11080000, 0x11080400,
1228 0x10080100, 0x10080500, 0x11080100, 0x11080500,
1229 0x10080100, 0x10080500, 0x11080100, 0x11080500,
1230 0x00000008, 0x00000408, 0x01000008, 0x01000408,
1231 0x00000008, 0x00000408, 0x01000008, 0x01000408,
1232 0x00000108, 0x00000508, 0x01000108, 0x01000508,
1233 0x00000108, 0x00000508, 0x01000108, 0x01000508,
1234 0x10000008, 0x10000408, 0x11000008, 0x11000408,
1235 0x10000008, 0x10000408, 0x11000008, 0x11000408,
1236 0x10000108, 0x10000508, 0x11000108, 0x11000508,
1237 0x10000108, 0x10000508, 0x11000108, 0x11000508,
1238 0x00080008, 0x00080408, 0x01080008, 0x01080408,
1239 0x00080008, 0x00080408, 0x01080008, 0x01080408,
1240 0x00080108, 0x00080508, 0x01080108, 0x01080508,
1241 0x00080108, 0x00080508, 0x01080108, 0x01080508,
1242 0x10080008, 0x10080408, 0x11080008, 0x11080408,
1243 0x10080008, 0x10080408, 0x11080008, 0x11080408,
1244 0x10080108, 0x10080508, 0x11080108, 0x11080508,
1245 0x10080108, 0x10080508, 0x11080108, 0x11080508,
1246 0x00001000, 0x00001400, 0x01001000, 0x01001400,
1247 0x00001000, 0x00001400, 0x01001000, 0x01001400,
1248 0x00001100, 0x00001500, 0x01001100, 0x01001500,
1249 0x00001100, 0x00001500, 0x01001100, 0x01001500,
1250 0x10001000, 0x10001400, 0x11001000, 0x11001400,
1251 0x10001000, 0x10001400, 0x11001000, 0x11001400,
1252 0x10001100, 0x10001500, 0x11001100, 0x11001500,
1253 0x10001100, 0x10001500, 0x11001100, 0x11001500,
1254 0x00081000, 0x00081400, 0x01081000, 0x01081400,
1255 0x00081000, 0x00081400, 0x01081000, 0x01081400,
1256 0x00081100, 0x00081500, 0x01081100, 0x01081500,
1257 0x00081100, 0x00081500, 0x01081100, 0x01081500,
1258 0x10081000, 0x10081400, 0x11081000, 0x11081400,
1259 0x10081000, 0x10081400, 0x11081000, 0x11081400,
1260 0x10081100, 0x10081500, 0x11081100, 0x11081500,
1261 0x10081100, 0x10081500, 0x11081100, 0x11081500,
1262 0x00001008, 0x00001408, 0x01001008, 0x01001408,
1263 0x00001008, 0x00001408, 0x01001008, 0x01001408,
1264 0x00001108, 0x00001508, 0x01001108, 0x01001508,
1265 0x00001108, 0x00001508, 0x01001108, 0x01001508,
1266 0x10001008, 0x10001408, 0x11001008, 0x11001408,
1267 0x10001008, 0x10001408, 0x11001008, 0x11001408,
1268 0x10001108, 0x10001508, 0x11001108, 0x11001508,
1269 0x10001108, 0x10001508, 0x11001108, 0x11001508,
1270 0x00081008, 0x00081408, 0x01081008, 0x01081408,
1271 0x00081008, 0x00081408, 0x01081008, 0x01081408,
1272 0x00081108, 0x00081508, 0x01081108, 0x01081508,
1273 0x00081108, 0x00081508, 0x01081108, 0x01081508,
1274 0x10081008, 0x10081408, 0x11081008, 0x11081408,
1275 0x10081008, 0x10081408, 0x11081008, 0x11081408,
1276 0x10081108, 0x10081508, 0x11081108, 0x11081508,
1277 0x10081108, 0x10081508, 0x11081108, 0x11081508,
1278 );
1279
1280 $keys = array();
1281 for ($des_round = 0; $des_round < $this->des_rounds; ++$des_round) {
1282 // pad the key and remove extra characters as appropriate.
1283 $key = str_pad(substr($this->key, $des_round * 8, 8), 8, "\0");
1284
1285 // Perform the PC/1 transformation and compute C and D.
1286 $t = unpack('Nl/Nr', $key);
1287 list($l, $r) = array($t['l'], $t['r']);
1288 $key = ($this->shuffle[$pc1map[$r & 0xFF]] & "\x80\x80\x80\x80\x80\x80\x80\x00") | // This code handles data encryption used by ManageWP and is not a security issue.
1289 ($this->shuffle[$pc1map[($r >> 8) & 0xFF]] & "\x40\x40\x40\x40\x40\x40\x40\x00") |
1290 ($this->shuffle[$pc1map[($r >> 16) & 0xFF]] & "\x20\x20\x20\x20\x20\x20\x20\x00") |
1291 ($this->shuffle[$pc1map[($r >> 24) & 0xFF]] & "\x10\x10\x10\x10\x10\x10\x10\x00") |
1292 ($this->shuffle[$pc1map[$l & 0xFF]] & "\x08\x08\x08\x08\x08\x08\x08\x00") |
1293 ($this->shuffle[$pc1map[($l >> 8) & 0xFF]] & "\x04\x04\x04\x04\x04\x04\x04\x00") |
1294 ($this->shuffle[$pc1map[($l >> 16) & 0xFF]] & "\x02\x02\x02\x02\x02\x02\x02\x00") |
1295 ($this->shuffle[$pc1map[($l >> 24) & 0xFF]] & "\x01\x01\x01\x01\x01\x01\x01\x00");
1296 $key = unpack('Nc/Nd', $key);
1297 $c = ($key['c'] >> 4) & 0x0FFFFFFF;
1298 $d = (($key['d'] >> 4) & 0x0FFFFFF0) | ($key['c'] & 0x0F);
1299
1300 $keys[$des_round] = array(
1301 CRYPT_DES_ENCRYPT => array(),
1302 CRYPT_DES_DECRYPT => array_fill(0, 32, 0),
1303 );
1304 for ($i = 0, $ki = 31; $i < 16; ++$i, $ki -= 2) {
1305 $c <<= $shifts[$i];
1306 $c = ($c | ($c >> 28)) & 0x0FFFFFFF;
1307 $d <<= $shifts[$i];
1308 $d = ($d | ($d >> 28)) & 0x0FFFFFFF;
1309
1310 // Perform the PC-2 transformation.
1311 $cp = $pc2mapc1[$c >> 24] | $pc2mapc2[($c >> 16) & 0xFF] |
1312 $pc2mapc3[($c >> 8) & 0xFF] | $pc2mapc4[$c & 0xFF];
1313 $dp = $pc2mapd1[$d >> 24] | $pc2mapd2[($d >> 16) & 0xFF] |
1314 $pc2mapd3[($d >> 8) & 0xFF] | $pc2mapd4[$d & 0xFF];
1315
1316 // Reorder: odd bytes/even bytes. Push the result in key schedule.
1317 $val1 = ($cp & 0xFF000000) | (($cp << 8) & 0x00FF0000) |
1318 (($dp >> 16) & 0x0000FF00) | (($dp >> 8) & 0x000000FF);
1319 $val2 = (($cp << 8) & 0xFF000000) | (($cp << 16) & 0x00FF0000) |
1320 (($dp >> 8) & 0x0000FF00) | ($dp & 0x000000FF);
1321 $keys[$des_round][CRYPT_DES_ENCRYPT][] = $val1;
1322 $keys[$des_round][CRYPT_DES_DECRYPT][$ki - 1] = $val1;
1323 $keys[$des_round][CRYPT_DES_ENCRYPT][] = $val2;
1324 $keys[$des_round][CRYPT_DES_DECRYPT][$ki] = $val2;
1325 }
1326 }
1327
1328 switch ($this->des_rounds) {
1329 case 3: // 3DES keys
1330 $this->keys = array(
1331 CRYPT_DES_ENCRYPT => array_merge(
1332 $keys[0][CRYPT_DES_ENCRYPT],
1333 $keys[1][CRYPT_DES_DECRYPT],
1334 $keys[2][CRYPT_DES_ENCRYPT]
1335 ),
1336 CRYPT_DES_DECRYPT => array_merge(
1337 $keys[2][CRYPT_DES_DECRYPT],
1338 $keys[1][CRYPT_DES_ENCRYPT],
1339 $keys[0][CRYPT_DES_DECRYPT]
1340 ),
1341 );
1342 break;
1343 // case 1: // DES keys
1344 default:
1345 $this->keys = array(
1346 CRYPT_DES_ENCRYPT => $keys[0][CRYPT_DES_ENCRYPT],
1347 CRYPT_DES_DECRYPT => $keys[0][CRYPT_DES_DECRYPT],
1348 );
1349 }
1350 }
1351
1352 /**
1353 * Setup the performance-optimized function for de/encrypt()
1354 *
1355 * @see Crypt_Base::_setupInlineCrypt()
1356 * @access private
1357 */
1358 public function _setupInlineCrypt()
1359 {
1360 $lambda_functions = & Crypt_DES::_getLambdaFunctions();
1361
1362 // Engine configuration for:
1363 // - DES ($des_rounds == 1) or
1364 // - 3DES ($des_rounds == 3)
1365 $des_rounds = $this->des_rounds;
1366
1367 // We create max. 10 hi-optimized code for memory reason. Means: For each $key one ultra fast inline-crypt function.
1368 // After that, we'll still create very fast optimized code but not the hi-ultimative code, for each $mode one
1369 $gen_hi_opt_code = (bool) (count($lambda_functions) < 10);
1370
1371 // Generation of a uniqe hash for our generated code
1372 switch (true) {
1373 case $gen_hi_opt_code:
1374 // For hi-optimized code, we create for each combination of
1375 // $mode, $des_rounds and $this->key its own encrypt/decrypt function.
1376 $code_hash = md5(str_pad("Crypt_DES, $des_rounds, {$this->mode}, ", 32, "\0").$this->key);
1377 break;
1378 default:
1379 // After max 10 hi-optimized functions, we create generic
1380 // (still very fast.. but not ultra) functions for each $mode/$des_rounds
1381 // Currently 2 * 5 generic functions will be then max. possible.
1382 $code_hash = "Crypt_DES, $des_rounds, {$this->mode}";
1383 }
1384
1385 // Is there a re-usable $lambda_functions in there? If not, we have to create it.
1386 if (!isset($lambda_functions[$code_hash])) {
1387 // Init code for both, encrypt and decrypt.
1388 $init_crypt = 'static $sbox1, $sbox2, $sbox3, $sbox4, $sbox5, $sbox6, $sbox7, $sbox8, $shuffleip, $shuffleinvip;
1389 if (!$sbox1) {
1390 $sbox1 = array_map("intval", $self->sbox1);
1391 $sbox2 = array_map("intval", $self->sbox2);
1392 $sbox3 = array_map("intval", $self->sbox3);
1393 $sbox4 = array_map("intval", $self->sbox4);
1394 $sbox5 = array_map("intval", $self->sbox5);
1395 $sbox6 = array_map("intval", $self->sbox6);
1396 $sbox7 = array_map("intval", $self->sbox7);
1397 $sbox8 = array_map("intval", $self->sbox8);'
1398 /* Merge $shuffle with $[inv]ipmap */.'
1399 for ($i = 0; $i < 256; ++$i) {
1400 $shuffleip[] = $self->shuffle[$self->ipmap[$i]];
1401 $shuffleinvip[] = $self->shuffle[$self->invipmap[$i]];
1402 }
1403 }
1404 ';
1405
1406 switch (true) {
1407 case $gen_hi_opt_code:
1408 // In Hi-optimized code mode, we use our [3]DES key schedule as hardcoded integers.
1409 // No futher initialisation of the $keys schedule is necessary.
1410 // That is the extra performance boost.
1411 $k = array(
1412 CRYPT_DES_ENCRYPT => $this->keys[CRYPT_DES_ENCRYPT],
1413 CRYPT_DES_DECRYPT => $this->keys[CRYPT_DES_DECRYPT],
1414 );
1415 $init_encrypt = '';
1416 $init_decrypt = '';
1417 break;
1418 default:
1419 // In generic optimized code mode, we have to use, as the best compromise [currently],
1420 // our key schedule as $ke/$kd arrays. (with hardcoded indexes...)
1421 $k = array(
1422 CRYPT_DES_ENCRYPT => array(),
1423 CRYPT_DES_DECRYPT => array(),
1424 );
1425 for ($i = 0, $c = count($this->keys[CRYPT_DES_ENCRYPT]); $i < $c; ++$i) {
1426 $k[CRYPT_DES_ENCRYPT][$i] = '$ke['.$i.']';
1427 $k[CRYPT_DES_DECRYPT][$i] = '$kd['.$i.']';
1428 }
1429 $init_encrypt = '$ke = $self->keys[CRYPT_DES_ENCRYPT];';
1430 $init_decrypt = '$kd = $self->keys[CRYPT_DES_DECRYPT];';
1431 break;
1432 }
1433
1434 // Creating code for en- and decryption.
1435 $crypt_block = array();
1436 foreach (array(CRYPT_DES_ENCRYPT, CRYPT_DES_DECRYPT) as $c) {
1437 /* Do the initial IP permutation. */
1438 $crypt_block[$c] = '
1439 $in = unpack("N*", $in);
1440 $l = $in[1];
1441 $r = $in[2];
1442 $in = unpack("N*",
1443 ($shuffleip[ $r & 0xFF] & "\x80\x80\x80\x80\x80\x80\x80\x80") | // This code handles data encryption used by ManageWP and is not a security issue.
1444 ($shuffleip[($r >> 8) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
1445 ($shuffleip[($r >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
1446 ($shuffleip[($r >> 24) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
1447 ($shuffleip[ $l & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
1448 ($shuffleip[($l >> 8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
1449 ($shuffleip[($l >> 16) & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
1450 ($shuffleip[($l >> 24) & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01")
1451 );
1452 './* Extract L0 and R0 */
1453 '
1454 $l = $in[1];
1455 $r = $in[2];
1456 ';
1457
1458 $l = '$l';
1459 $r = '$r';
1460
1461 // Perform DES or 3DES.
1462 for ($ki = -1, $des_round = 0; $des_round < $des_rounds; ++$des_round) {
1463 // Perform the 16 steps.
1464 for ($i = 0; $i < 16; ++$i) {
1465 // start of "the Feistel (F) function" - see the following URL:
1466 // http://en.wikipedia.org/wiki/Image:Data_Encryption_Standard_InfoBox_Diagram.png
1467 // Merge key schedule.
1468 $crypt_block[$c] .= '
1469 $b1 = (('.$r.' >> 3) & 0x1FFFFFFF) ^ ('.$r.' << 29) ^ '.$k[$c][++$ki].';
1470 $b2 = (('.$r.' >> 31) & 0x00000001) ^ ('.$r.' << 1) ^ '.$k[$c][++$ki].';'.
1471 /* S-box indexing. */
1472 $l.' = $sbox1[($b1 >> 24) & 0x3F] ^ $sbox2[($b2 >> 24) & 0x3F] ^
1473 $sbox3[($b1 >> 16) & 0x3F] ^ $sbox4[($b2 >> 16) & 0x3F] ^
1474 $sbox5[($b1 >> 8) & 0x3F] ^ $sbox6[($b2 >> 8) & 0x3F] ^
1475 $sbox7[ $b1 & 0x3F] ^ $sbox8[ $b2 & 0x3F] ^ '.$l.';
1476 ';
1477 // end of "the Feistel (F) function"
1478
1479 // swap L & R
1480 list($l, $r) = array($r, $l);
1481 }
1482 list($l, $r) = array($r, $l);
1483 }
1484
1485 // Perform the inverse IP permutation.
1486 $crypt_block[$c] .= '$in =
1487 ($shuffleinvip[($l >> 24) & 0xFF] & "\x80\x80\x80\x80\x80\x80\x80\x80") | // This code handles data encryption used by ManageWP and is not a security issue.
1488 ($shuffleinvip[($r >> 24) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
1489 ($shuffleinvip[($l >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
1490 ($shuffleinvip[($r >> 16) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
1491 ($shuffleinvip[($l >> 8) & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
1492 ($shuffleinvip[($r >> 8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
1493 ($shuffleinvip[ $l & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
1494 ($shuffleinvip[ $r & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
1495 ';
1496 }
1497
1498 // Creates the inline-crypt function
1499 $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
1500 array(
1501 'init_crypt' => $init_crypt,
1502 'init_encrypt' => $init_encrypt,
1503 'init_decrypt' => $init_decrypt,
1504 'encrypt_block' => $crypt_block[CRYPT_DES_ENCRYPT],
1505 'decrypt_block' => $crypt_block[CRYPT_DES_DECRYPT],
1506 )
1507 );
1508 }
1509
1510 // Set the inline-crypt function as callback in: $this->inline_crypt
1511 $this->inline_crypt = $lambda_functions[$code_hash];
1512 }
1513 }
1514