/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/system/libraries/Encrypt.php

  • Committer: gustav.hartvigsson at gmail
  • Date: 2013-04-03 11:52:56 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20130403115256-sz6zermzoom4lifc
Ignored .DS_Store files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/system/libraries/Encrypt.php
1
 
<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
2
 
/**
3
 
 * CodeIgniter
4
 
 *
5
 
 * An open source application development framework for PHP 5.1.6 or newer
6
 
 *
7
 
 * @package             CodeIgniter
8
 
 * @author              ExpressionEngine Dev Team
9
 
 * @copyright   Copyright (c) 2008 - 2011, EllisLab, Inc.
10
 
 * @license             http://codeigniter.com/user_guide/license.html
11
 
 * @link                http://codeigniter.com
12
 
 * @since               Version 1.0
13
 
 * @filesource
14
 
 */
15
 
 
16
 
// ------------------------------------------------------------------------
17
 
 
18
 
/**
19
 
 * CodeIgniter Encryption Class
20
 
 *
21
 
 * Provides two-way keyed encoding using XOR Hashing and Mcrypt
22
 
 *
23
 
 * @package             CodeIgniter
24
 
 * @subpackage  Libraries
25
 
 * @category    Libraries
26
 
 * @author              ExpressionEngine Dev Team
27
 
 * @link                http://codeigniter.com/user_guide/libraries/encryption.html
28
 
 */
29
 
class CI_Encrypt {
30
 
 
31
 
        var $CI;
32
 
        var $encryption_key     = '';
33
 
        var $_hash_type = 'sha1';
34
 
        var $_mcrypt_exists = FALSE;
35
 
        var $_mcrypt_cipher;
36
 
        var $_mcrypt_mode;
37
 
 
38
 
        /**
39
 
         * Constructor
40
 
         *
41
 
         * Simply determines whether the mcrypt library exists.
42
 
         *
43
 
         */
44
 
        public function __construct()
45
 
        {
46
 
                $this->CI =& get_instance();
47
 
                $this->_mcrypt_exists = ( ! function_exists('mcrypt_encrypt')) ? FALSE : TRUE;
48
 
                log_message('debug', "Encrypt Class Initialized");
49
 
        }
50
 
 
51
 
        // --------------------------------------------------------------------
52
 
 
53
 
        /**
54
 
         * Fetch the encryption key
55
 
         *
56
 
         * Returns it as MD5 in order to have an exact-length 128 bit key.
57
 
         * Mcrypt is sensitive to keys that are not the correct length
58
 
         *
59
 
         * @access      public
60
 
         * @param       string
61
 
         * @return      string
62
 
         */
63
 
        function get_key($key = '')
64
 
        {
65
 
                if ($key == '')
66
 
                {
67
 
                        if ($this->encryption_key != '')
68
 
                        {
69
 
                                return $this->encryption_key;
70
 
                        }
71
 
 
72
 
                        $CI =& get_instance();
73
 
                        $key = $CI->config->item('encryption_key');
74
 
 
75
 
                        if ($key == FALSE)
76
 
                        {
77
 
                                show_error('In order to use the encryption class requires that you set an encryption key in your config file.');
78
 
                        }
79
 
                }
80
 
 
81
 
                return md5($key);
82
 
        }
83
 
 
84
 
        // --------------------------------------------------------------------
85
 
 
86
 
        /**
87
 
         * Set the encryption key
88
 
         *
89
 
         * @access      public
90
 
         * @param       string
91
 
         * @return      void
92
 
         */
93
 
        function set_key($key = '')
94
 
        {
95
 
                $this->encryption_key = $key;
96
 
        }
97
 
 
98
 
        // --------------------------------------------------------------------
99
 
 
100
 
        /**
101
 
         * Encode
102
 
         *
103
 
         * Encodes the message string using bitwise XOR encoding.
104
 
         * The key is combined with a random hash, and then it
105
 
         * too gets converted using XOR. The whole thing is then run
106
 
         * through mcrypt (if supported) using the randomized key.
107
 
         * The end result is a double-encrypted message string
108
 
         * that is randomized with each call to this function,
109
 
         * even if the supplied message and key are the same.
110
 
         *
111
 
         * @access      public
112
 
         * @param       string  the string to encode
113
 
         * @param       string  the key
114
 
         * @return      string
115
 
         */
116
 
        function encode($string, $key = '')
117
 
        {
118
 
                $key = $this->get_key($key);
119
 
 
120
 
                if ($this->_mcrypt_exists === TRUE)
121
 
                {
122
 
                        $enc = $this->mcrypt_encode($string, $key);
123
 
                }
124
 
                else
125
 
                {
126
 
                        $enc = $this->_xor_encode($string, $key);
127
 
                }
128
 
 
129
 
                return base64_encode($enc);
130
 
        }
131
 
 
132
 
        // --------------------------------------------------------------------
133
 
 
134
 
        /**
135
 
         * Decode
136
 
         *
137
 
         * Reverses the above process
138
 
         *
139
 
         * @access      public
140
 
         * @param       string
141
 
         * @param       string
142
 
         * @return      string
143
 
         */
144
 
        function decode($string, $key = '')
145
 
        {
146
 
                $key = $this->get_key($key);
147
 
 
148
 
                if (preg_match('/[^a-zA-Z0-9\/\+=]/', $string))
149
 
                {
150
 
                        return FALSE;
151
 
                }
152
 
 
153
 
                $dec = base64_decode($string);
154
 
 
155
 
                if ($this->_mcrypt_exists === TRUE)
156
 
                {
157
 
                        if (($dec = $this->mcrypt_decode($dec, $key)) === FALSE)
158
 
                        {
159
 
                                return FALSE;
160
 
                        }
161
 
                }
162
 
                else
163
 
                {
164
 
                        $dec = $this->_xor_decode($dec, $key);
165
 
                }
166
 
 
167
 
                return $dec;
168
 
        }
169
 
 
170
 
        // --------------------------------------------------------------------
171
 
 
172
 
        /**
173
 
         * Encode from Legacy
174
 
         *
175
 
         * Takes an encoded string from the original Encryption class algorithms and
176
 
         * returns a newly encoded string using the improved method added in 2.0.0
177
 
         * This allows for backwards compatibility and a method to transition to the
178
 
         * new encryption algorithms.
179
 
         *
180
 
         * For more details, see http://codeigniter.com/user_guide/installation/upgrade_200.html#encryption
181
 
         *
182
 
         * @access      public
183
 
         * @param       string
184
 
         * @param       int             (mcrypt mode constant)
185
 
         * @param       string
186
 
         * @return      string
187
 
         */
188
 
        function encode_from_legacy($string, $legacy_mode = MCRYPT_MODE_ECB, $key = '')
189
 
        {
190
 
                if ($this->_mcrypt_exists === FALSE)
191
 
                {
192
 
                        log_message('error', 'Encoding from legacy is available only when Mcrypt is in use.');
193
 
                        return FALSE;
194
 
                }
195
 
 
196
 
                // decode it first
197
 
                // set mode temporarily to what it was when string was encoded with the legacy
198
 
                // algorithm - typically MCRYPT_MODE_ECB
199
 
                $current_mode = $this->_get_mode();
200
 
                $this->set_mode($legacy_mode);
201
 
 
202
 
                $key = $this->get_key($key);
203
 
 
204
 
                if (preg_match('/[^a-zA-Z0-9\/\+=]/', $string))
205
 
                {
206
 
                        return FALSE;
207
 
                }
208
 
 
209
 
                $dec = base64_decode($string);
210
 
 
211
 
                if (($dec = $this->mcrypt_decode($dec, $key)) === FALSE)
212
 
                {
213
 
                        return FALSE;
214
 
                }
215
 
 
216
 
                $dec = $this->_xor_decode($dec, $key);
217
 
 
218
 
                // set the mcrypt mode back to what it should be, typically MCRYPT_MODE_CBC
219
 
                $this->set_mode($current_mode);
220
 
 
221
 
                // and re-encode
222
 
                return base64_encode($this->mcrypt_encode($dec, $key));
223
 
        }
224
 
 
225
 
        // --------------------------------------------------------------------
226
 
 
227
 
        /**
228
 
         * XOR Encode
229
 
         *
230
 
         * Takes a plain-text string and key as input and generates an
231
 
         * encoded bit-string using XOR
232
 
         *
233
 
         * @access      private
234
 
         * @param       string
235
 
         * @param       string
236
 
         * @return      string
237
 
         */
238
 
        function _xor_encode($string, $key)
239
 
        {
240
 
                $rand = '';
241
 
                while (strlen($rand) < 32)
242
 
                {
243
 
                        $rand .= mt_rand(0, mt_getrandmax());
244
 
                }
245
 
 
246
 
                $rand = $this->hash($rand);
247
 
 
248
 
                $enc = '';
249
 
                for ($i = 0; $i < strlen($string); $i++)
250
 
                {
251
 
                        $enc .= substr($rand, ($i % strlen($rand)), 1).(substr($rand, ($i % strlen($rand)), 1) ^ substr($string, $i, 1));
252
 
                }
253
 
 
254
 
                return $this->_xor_merge($enc, $key);
255
 
        }
256
 
 
257
 
        // --------------------------------------------------------------------
258
 
 
259
 
        /**
260
 
         * XOR Decode
261
 
         *
262
 
         * Takes an encoded string and key as input and generates the
263
 
         * plain-text original message
264
 
         *
265
 
         * @access      private
266
 
         * @param       string
267
 
         * @param       string
268
 
         * @return      string
269
 
         */
270
 
        function _xor_decode($string, $key)
271
 
        {
272
 
                $string = $this->_xor_merge($string, $key);
273
 
 
274
 
                $dec = '';
275
 
                for ($i = 0; $i < strlen($string); $i++)
276
 
                {
277
 
                        $dec .= (substr($string, $i++, 1) ^ substr($string, $i, 1));
278
 
                }
279
 
 
280
 
                return $dec;
281
 
        }
282
 
 
283
 
        // --------------------------------------------------------------------
284
 
 
285
 
        /**
286
 
         * XOR key + string Combiner
287
 
         *
288
 
         * Takes a string and key as input and computes the difference using XOR
289
 
         *
290
 
         * @access      private
291
 
         * @param       string
292
 
         * @param       string
293
 
         * @return      string
294
 
         */
295
 
        function _xor_merge($string, $key)
296
 
        {
297
 
                $hash = $this->hash($key);
298
 
                $str = '';
299
 
                for ($i = 0; $i < strlen($string); $i++)
300
 
                {
301
 
                        $str .= substr($string, $i, 1) ^ substr($hash, ($i % strlen($hash)), 1);
302
 
                }
303
 
 
304
 
                return $str;
305
 
        }
306
 
 
307
 
        // --------------------------------------------------------------------
308
 
 
309
 
        /**
310
 
         * Encrypt using Mcrypt
311
 
         *
312
 
         * @access      public
313
 
         * @param       string
314
 
         * @param       string
315
 
         * @return      string
316
 
         */
317
 
        function mcrypt_encode($data, $key)
318
 
        {
319
 
                $init_size = mcrypt_get_iv_size($this->_get_cipher(), $this->_get_mode());
320
 
                $init_vect = mcrypt_create_iv($init_size, MCRYPT_RAND);
321
 
                return $this->_add_cipher_noise($init_vect.mcrypt_encrypt($this->_get_cipher(), $key, $data, $this->_get_mode(), $init_vect), $key);
322
 
        }
323
 
 
324
 
        // --------------------------------------------------------------------
325
 
 
326
 
        /**
327
 
         * Decrypt using Mcrypt
328
 
         *
329
 
         * @access      public
330
 
         * @param       string
331
 
         * @param       string
332
 
         * @return      string
333
 
         */
334
 
        function mcrypt_decode($data, $key)
335
 
        {
336
 
                $data = $this->_remove_cipher_noise($data, $key);
337
 
                $init_size = mcrypt_get_iv_size($this->_get_cipher(), $this->_get_mode());
338
 
 
339
 
                if ($init_size > strlen($data))
340
 
                {
341
 
                        return FALSE;
342
 
                }
343
 
 
344
 
                $init_vect = substr($data, 0, $init_size);
345
 
                $data = substr($data, $init_size);
346
 
                return rtrim(mcrypt_decrypt($this->_get_cipher(), $key, $data, $this->_get_mode(), $init_vect), "\0");
347
 
        }
348
 
 
349
 
        // --------------------------------------------------------------------
350
 
 
351
 
        /**
352
 
         * Adds permuted noise to the IV + encrypted data to protect
353
 
         * against Man-in-the-middle attacks on CBC mode ciphers
354
 
         * http://www.ciphersbyritter.com/GLOSSARY.HTM#IV
355
 
         *
356
 
         * Function description
357
 
         *
358
 
         * @access      private
359
 
         * @param       string
360
 
         * @param       string
361
 
         * @return      string
362
 
         */
363
 
        function _add_cipher_noise($data, $key)
364
 
        {
365
 
                $keyhash = $this->hash($key);
366
 
                $keylen = strlen($keyhash);
367
 
                $str = '';
368
 
 
369
 
                for ($i = 0, $j = 0, $len = strlen($data); $i < $len; ++$i, ++$j)
370
 
                {
371
 
                        if ($j >= $keylen)
372
 
                        {
373
 
                                $j = 0;
374
 
                        }
375
 
 
376
 
                        $str .= chr((ord($data[$i]) + ord($keyhash[$j])) % 256);
377
 
                }
378
 
 
379
 
                return $str;
380
 
        }
381
 
 
382
 
        // --------------------------------------------------------------------
383
 
 
384
 
        /**
385
 
         * Removes permuted noise from the IV + encrypted data, reversing
386
 
         * _add_cipher_noise()
387
 
         *
388
 
         * Function description
389
 
         *
390
 
         * @access      public
391
 
         * @param       type
392
 
         * @return      type
393
 
         */
394
 
        function _remove_cipher_noise($data, $key)
395
 
        {
396
 
                $keyhash = $this->hash($key);
397
 
                $keylen = strlen($keyhash);
398
 
                $str = '';
399
 
 
400
 
                for ($i = 0, $j = 0, $len = strlen($data); $i < $len; ++$i, ++$j)
401
 
                {
402
 
                        if ($j >= $keylen)
403
 
                        {
404
 
                                $j = 0;
405
 
                        }
406
 
 
407
 
                        $temp = ord($data[$i]) - ord($keyhash[$j]);
408
 
 
409
 
                        if ($temp < 0)
410
 
                        {
411
 
                                $temp = $temp + 256;
412
 
                        }
413
 
 
414
 
                        $str .= chr($temp);
415
 
                }
416
 
 
417
 
                return $str;
418
 
        }
419
 
 
420
 
        // --------------------------------------------------------------------
421
 
 
422
 
        /**
423
 
         * Set the Mcrypt Cipher
424
 
         *
425
 
         * @access      public
426
 
         * @param       constant
427
 
         * @return      string
428
 
         */
429
 
        function set_cipher($cipher)
430
 
        {
431
 
                $this->_mcrypt_cipher = $cipher;
432
 
        }
433
 
 
434
 
        // --------------------------------------------------------------------
435
 
 
436
 
        /**
437
 
         * Set the Mcrypt Mode
438
 
         *
439
 
         * @access      public
440
 
         * @param       constant
441
 
         * @return      string
442
 
         */
443
 
        function set_mode($mode)
444
 
        {
445
 
                $this->_mcrypt_mode = $mode;
446
 
        }
447
 
 
448
 
        // --------------------------------------------------------------------
449
 
 
450
 
        /**
451
 
         * Get Mcrypt cipher Value
452
 
         *
453
 
         * @access      private
454
 
         * @return      string
455
 
         */
456
 
        function _get_cipher()
457
 
        {
458
 
                if ($this->_mcrypt_cipher == '')
459
 
                {
460
 
                        $this->_mcrypt_cipher = MCRYPT_RIJNDAEL_256;
461
 
                }
462
 
 
463
 
                return $this->_mcrypt_cipher;
464
 
        }
465
 
 
466
 
        // --------------------------------------------------------------------
467
 
 
468
 
        /**
469
 
         * Get Mcrypt Mode Value
470
 
         *
471
 
         * @access      private
472
 
         * @return      string
473
 
         */
474
 
        function _get_mode()
475
 
        {
476
 
                if ($this->_mcrypt_mode == '')
477
 
                {
478
 
                        $this->_mcrypt_mode = MCRYPT_MODE_CBC;
479
 
                }
480
 
 
481
 
                return $this->_mcrypt_mode;
482
 
        }
483
 
 
484
 
        // --------------------------------------------------------------------
485
 
 
486
 
        /**
487
 
         * Set the Hash type
488
 
         *
489
 
         * @access      public
490
 
         * @param       string
491
 
         * @return      string
492
 
         */
493
 
        function set_hash($type = 'sha1')
494
 
        {
495
 
                $this->_hash_type = ($type != 'sha1' AND $type != 'md5') ? 'sha1' : $type;
496
 
        }
497
 
 
498
 
        // --------------------------------------------------------------------
499
 
 
500
 
        /**
501
 
         * Hash encode a string
502
 
         *
503
 
         * @access      public
504
 
         * @param       string
505
 
         * @return      string
506
 
         */
507
 
        function hash($str)
508
 
        {
509
 
                return ($this->_hash_type == 'sha1') ? $this->sha1($str) : md5($str);
510
 
        }
511
 
 
512
 
        // --------------------------------------------------------------------
513
 
 
514
 
        /**
515
 
         * Generate an SHA1 Hash
516
 
         *
517
 
         * @access      public
518
 
         * @param       string
519
 
         * @return      string
520
 
         */
521
 
        function sha1($str)
522
 
        {
523
 
                if ( ! function_exists('sha1'))
524
 
                {
525
 
                        if ( ! function_exists('mhash'))
526
 
                        {
527
 
                                require_once(BASEPATH.'libraries/Sha1.php');
528
 
                                $SH = new CI_SHA;
529
 
                                return $SH->generate($str);
530
 
                        }
531
 
                        else
532
 
                        {
533
 
                                return bin2hex(mhash(MHASH_SHA1, $str));
534
 
                        }
535
 
                }
536
 
                else
537
 
                {
538
 
                        return sha1($str);
539
 
                }
540
 
        }
541
 
 
542
 
}
543
 
 
544
 
// END CI_Encrypt class
545
 
 
546
 
/* End of file Encrypt.php */
547
 
/* Location: ./system/libraries/Encrypt.php */
 
 
b'\\ No newline at end of file'