/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 Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

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'