File: vendor/jackbooted/security/Cryptography.php

Recommend this page to a friend!
  Classes of Brett Dutton  >  JackBooted PHP Framework  >  vendor/jackbooted/security/Cryptography.php  >  Download  
File: vendor/jackbooted/security/Cryptography.php
Role: Class source
Content type: text/plain
Description: Class source
Class: JackBooted PHP Framework
Web application framework using simplified MVC
Author: By
Last change:
Date: 4 years ago
Size: 4,666 bytes
 

 

Contents

Class file image Download
<?php
namespace Jackbooted\Security;

use \
Jackbooted\Config\Cfg;
use \
Jackbooted\G;
use \
Jackbooted\Util\Log4PHP;
/*
 * @copyright Confidential and copyright (c) 2016 Jackbooted Software. All rights reserved.
 *
 * Written by Brett Dutton of Jackbooted Software
 * brett at brettdutton dot com
 *
 * This software is written and distributed under the GNU General Public
 * License which means that its source code is freely-distributed and
 * available to the general public.
 */

/**
 * Description of Encryption
 *
 * @author bdutton
 */
class Cryptography extends \Jackbooted\Util\JB {

   
//echo str_shuffle ( 'PredefinedEncryptionKey12345678901234567' );
   
const RAND_KEY = '4n5d73rde315E486pe9t7oy2nirefcPKnie0y126';

    const
META = ':e:';
    const
META_LEN = 3;
    const
PADDING = ' ';

    private static
$randKey;
    private static
$instance = null;
    private static
$log;
    private static
$encryptionOff = false;
    private static
$algortithm;

    public static function
init () {
       
self::$log = Log4PHP::logFactory ( __CLASS__ );
       
self::$encryptionOff = Cfg::get ( 'encrypt_override' );
        if ( !
function_exists ( 'mcrypt_get_key_size' ) ) {
           
self::$encryptionOff = true;
        }

       
// The IV is session specific. See if the key has been set in the session
       
if ( isset ( $_SESSION[G::SESS][G::CRYPTO] ) ) {
           
self::$randKey = md5 ( $_SESSION[G::SESS][G::CRYPTO] );
        }
        else {
           
self::$randKey = md5 ( self::RAND_KEY );
           
self::$log->warn ( 'Using the default key for crypto' );
        }

        if ( !
self::$encryptionOff ) {
           
self::$algortithm = ( Cfg::get ( 'quercus', false ) ) ? MCRYPT_TRIPLEDES : MCRYPT_RIJNDAEL_256;
        }

       
self::$instance = new Cryptography ( self::$randKey );
    }

   
/**
     * General encryption method
     * @param string $plainText
     * @return string
     */
   
public static function en ( $plainText ) {
        return
self::$instance->encrypt ( $plainText );
    }

   
/**
     * generalized decryption methd.
     * @param string $cypherText
     * @return string
     */
   
public static function de ( $cypherText ) {
        return
self::$instance->decrypt ( $cypherText );
    }

    public static function
factory ( $l_key=null ) {
        return new
Cryptography( $l_key );
    }

    private
$td;
    private
$blockLength;

   
/**
     *
     * @param string $l_key Key to use for encryption
     */
   
public function __construct ( $l_key=null ) {
       
parent::__construct();

        if (
self::$encryptionOff ) {
            return;
        }

       
$plainTextKey = ( $l_key == null ) ? self::$randKey : $l_key;

       
$keySize = mcrypt_get_key_size ( self::$algortithm, MCRYPT_MODE_ECB );
        while (
strlen ( $plainTextKey ) < $keySize ) $plainTextKey .= $plainTextKey;
       
$plainTextKey = substr ( $plainTextKey, 0, $keySize );

       
$this->blockLength = mcrypt_get_block_size ( self::$algortithm, MCRYPT_MODE_ECB );
       
$this->td = mcrypt_module_open ( self::$algortithm, '', MCRYPT_MODE_ECB, '' );

       
$iv = mcrypt_create_iv ( mcrypt_enc_get_iv_size ( $this->td ), MCRYPT_RAND );
       
mcrypt_generic_init ( $this->td, $plainTextKey, $iv );
    }
   
/**
     * encrypt the passed string
     * @param string $input
     * @return string
     */
   
public function encrypt ( $plainText, $force=false ) {
        if (
self::$encryptionOff && ! $force ) return $plainText;
        if ( ! isset (
$plainText ) || strlen ( $plainText ) == 0 ) {
            return
$plainText;
        }

       
$len = strlen ( $plainText ) % $this->blockLength;
        if (
$len != 0 ) {
           
$charactersNeeded = $this->blockLength - $len;
           
$plainText .= substr ( self::PADDING, 0, $charactersNeeded );
        }

       
$m = mcrypt_generic ( $this->td, $plainText );
       
$cypherText = self::META . base64_encode ( $m );
        return
$cypherText;
    }

    public function
decrypt ( $cypherText ) {
        if (
strpos ( $cypherText, self::META ) !== 0 ) return $cypherText;
       
$plainText = trim ( mdecrypt_generic ( $this->td, base64_decode ( substr ( $cypherText, self::META_LEN ) ) ) );
        return
$plainText;
    }

   
/**
     * Clean up the crypto resources when they go out of scope
     */
   
public function __destruct() {
        if (
function_exists ( 'mcrypt_generic_deinit' ) && $this->td != null ) mcrypt_generic_deinit ( $this->td );
        if (
function_exists ( 'mcrypt_module_close' ) && $this->td != null ) mcrypt_module_close ( $this->td );
    }
}


For more information send a message to info at phpclasses dot org.