flourishlib / flourish-classes Goto Github PK

$req = new sHTTP('http://theXMLsite.com?alt=json', 'POST');
$req->setContent('post data');
$data = fJSON::decode($req->getData());

if (strpos($command_line, ' -colorspace ') === FALSE) {
            $command_line .= ' -colorspace RGB ';
        }

$users = $group->buildUsers(array('status=' => 'active'));

try {
    $db  = new fDatabase('mssql', 'TEST', 'sa', '123456','PHUOCDAI-PC\SQLEXPRESS');
    // Please note that calling this method is not required, and simply
    // causes an exception to be thrown if the connection can not be made
    $db->connect();

} catch (fAuthorizationException $e) {
    $e->printMessage();
}

class User extends fActiveRecord {
  const nameIsAvailable = 'User::nameIsAvailable';

  public static function nameIsAvailable($name) {
    try {
      new self(array('name' => $name));
      return FALSE; // is taken
    }
    catch (fNotFoundException $e) {}
    return TRUE;
  }
}

// later code
try {
  $validation = new fValidation;
  $validation->addRequiredFields('name');
  $validation->addCallbackRule('name', User::nameIsAvailable, 'Sorry, that user name is taken.');
  $validation->validate();
  fURL::redirect('/');
}
catch (fValidationException $e) {
  fMessaging::create('validation', '/registration' $e->getMessage());
  fURL::redirect('/registration');
}

try {
  $validation = new fValidation;
  // Add conditions
  $validation->validate();

  // Method that throws with a specific message
  SomeClass::validateAdditionalConditions();
}
catch (fValidationException $e) {
  // Do something based on the error
}

$validation = new fValidation;
$validation->setRequiredFields('accepted'); // checkbox
$validation->setRequiredFieldMessages(array(
  'accepted' => 'You must accept the terms and conditions to register.',
));
$validation->validate();

class fValidation() {
  public function addRequiredFields(array $fields, array $messages) {}
  public function addRequiredFields(array $fields_to_messages) {} // as you described
}

$pk_columns = $schema→getKeys($table, 'primary');

    foreach ($pk_columns as $column) {

// error happens here

    $value = $row[$column]; if ($value !== NULL && isset(self::$unescape_map[$class][$column])) {

        $value = $db→unescape(self::$unescape_map[$class][$column], $value);

    }

    $this→values[$column] = fORMobjectify($class, $column, $value); unset($row[$column]);

    }

    if (isset($relationshipjoin_table?)) {

        unset($row[$relationshipcolumn?]);

    }

/**
 * Forces use as a static class
 *
 * @return fORMValidation
 */
  private function __construct() {
  }

<?php 

    class fORMRequest{

        const populate  = 'fORMRequest::populate';
        const hydrate  = 'fORMRequest::hydrate';
        const addProtectedColumns  = 'fORMRequest::addProtectedColumns';
        const addAccessibleColumns  = 'fORMRequest::addAccessibleColumns';

        static private $protected_columns = array();

        static public function extend(){
            fORM::registerActiveRecordMethod(
                '*',
                'populate',
                self::populate
            );

            fORM::registerActiveRecordMethod(
                '*',
                'hydrate',
                self::hydrate
            );
        }

        static public function hydrate($object, &$values, &$old_values, &$related_records, &$cache, $method_name, $parameters){
            $class = get_class($object);
            $new_values = $parameters[0];

            fORM::callHookCallbacks(
                $object,
                'pre::hydrate()',
                $values,
                $old_values,
                $related_records,
                $cache
            );

            if(!is_array($new_values)){
                throw fProgrammerException(
                    'The hydrate method requires an associated array to populate the values'
                );
            }

            $schema = fORMSchema::retrieve($class);
            $table  = fORM::tablize($class);
            $new_value_keys = array_keys($new_values);
            $column_info = $schema->getColumnInfo($table);
            foreach ($column_info as $column => $info) {
                if (in_array($column,$new_value_keys)) {
                    $method = 'set' . fGrammar::camelize($column, TRUE);
                    $cast_to = ($info['type'] == 'blob') ? 'binary' : NULL;
                    $object->$method($new_values[$column]);
                }
            }

            fORM::callHookCallbacks(
                $object,
                'post::hydrate()',
                $values,
                $old_values,
                $related_records,
                $cache
            );

            return $object;
        }

        static public function populate($object, &$values, &$old_values, &$related_records, &$cache, $method_name, $parameters)
        {
            $class = get_class($object);

            fORM::callHookCallbacks(
                $object,
                'pre::populate()',
                $values,
                $old_values,
                $related_records,
                $cache
            );

            $schema = fORMSchema::retrieve($class);
            $table  = fORM::tablize($class);

            $column_info = $schema->getColumnInfo($table);

            foreach ($column_info as $column => $info) {
                //Ignore protected coulmns
                if(isset(self::$protected_columns[$class]) && in_array($column,self::$protected_columns[$class])){
                    continue;
                }
                if (fRequest::check($column)) {
                    $method = 'set' . fGrammar::camelize($column, TRUE);
                    $cast_to = ($info['type'] == 'blob') ? 'binary' : NULL;
                    $object->$method(fRequest::get($column, $cast_to));
                }
            }

            fORM::callHookCallbacks(
                $object,
                'post::populate()',
                $values,
                $old_values,
                $related_records,
                $cache
            );

            return $object;
        }

        static public function addProtectedColumns($class, $columns){

            $class = fORM::getClass($class);

            settype($columns, 'array');


            if (!isset(self::$protected_columns[$class])) {
                self::$protected_columns[$class] = array();
            }

            foreach ($columns as $column) {
                if(!in_array($column,self::$protected_columns[$class])){
                    self::$protected_columns[$class][] = $column;
                }   
            }
        }

        static public function addAccessibleColumns($class, $columns){

            $class = fORM::getClass($class);

            $schema = fORMSchema::retrieve($class);
            $table  = fORM::tablize($class);
            $column_info = $schema->getColumnInfo($table);
            $column_names = array_keys($column_info);

                settype($columns, 'array');

            if (!isset(self::$protected_columns[$class])) {
                self::$protected_columns[$class] = array();
            }

            foreach ($column_names as $column) {
                if(!in_array($column,$columns) && !in_array($column,self::$protected_columns[$class])){
                    self::$protected_columns[$class][] = $column;
                }   
            }
        }
    }

$module   = mcrypt_module_open('rijndael-192', '', 'cfb', '');

$key_size = mcrypt_enc_get_key_size($module);
$iv_size = mcrypt_enc_get_iv_size($module);
$block_size = mcrypt_enc_get_block_size($module);

echo "\n\n\nKEY: $key_size\nIV: $iv_size\nBLOCK: $block_size";

<?php

function __autoload($class_name)
{
    if ( preg_match("/^f.+$/i", $class_name) ) {
        $class_root = $_SERVER['DOCUMENT_ROOT'] . '/lib/flourish/';
    }
    else {
        $class_root = $_SERVER['DOCUMENT_ROOT'] . '/lib/class/';
    }
    $file = $class_root . $class_name . '.php';

    if (file_exists($file)) {
        include $file;
        return;
    }

    throw new Exception('The class ' . $class_name . ' could not be loaded');
}

header('Content-type: text/plain');

$c = new Crypt_Rijndael(); unset($c);
// Load phpseclib using __autoload function

$secret = "secret";
$pw = "password";

$ciphertext = fCryptography::symmetricKeyEncrypt($secret, $pw);

echo "$ciphertext\n";
echo "fCryptography::symmetric-php^xxxxxxxxxxxxxxIVxxxxxxxxxxxxxxxx^xCIPHERx^xxxxxxxxxxxxxxxxxxHMACxxxxxxxxxxxxxxxxxx \n\n";
// This is a mask to check the form of the ciphertext

$ciphertext = str_replace('-php', '', $ciphertext);

$plain = fCryptography::symmetricKeyDecrypt($ciphertext, $pw);

echo "\nPHP-MCRYPT TEST:\n\n$ciphertext\n";
echo "fCryptography::symmetric^xxxxxxxxxxxxxxIVxxxxxxxxxxxxxxxx^xCIPHERx^xxxxxxxxxxxxxxxxxxHMACxxxxxxxxxxxxxxxxxx";
//echo "\n\n= $plain";
// (Uncomment to test)
?>

<?php
/**
 * Provides cryptography functionality, including hashing, symmetric-key encryption and public-key encryption
 * 
 * @copyright  Copyright (c) 2007-2010 Will Bond
 * @author     Will Bond [wb] <[email protected]>
 * @license    http://flourishlib.com/license
 * 
 * @patch      passcod [passcod] <[email protected]>
 *
 * @package    Flourish
 * @link       http://flourishlib.com/fCryptography
 * 
 * @version    1.0.0b14
 * @changes    1.0.0b14  Added support for phpseclib's pure-php symmetric de/encryption [passcod, 2010-11-07]
 * @changes    1.0.0b13  Updated documentation about symmetric-key encryption to explicitly state block and key sizes, added base64 type to ::randomString() [wb, 2010-11-06]
 * @changes    1.0.0b12  Fixed an inline comment that incorrectly references AES-256 [wb, 2010-11-04]
 * @changes    1.0.0b11  Updated class to use fCore::startErrorCapture() instead of `error_reporting()` [wb, 2010-08-09]
 * @changes    1.0.0b10  Added a missing parameter to an fProgrammerException in ::randomString() [wb, 2010-07-29]
 * @changes    1.0.0b9   Added ::hashHMAC() [wb, 2010-04-20]
 * @changes    1.0.0b8   Fixed ::seedRandom() to pass a directory instead of a file to [http://php.net/disk_free_space `disk_free_space()`] [wb, 2010-03-09]
 * @changes    1.0.0b7   SECURITY FIX: fixed issue with ::random() and ::randomString() not producing random output on OSX, made ::seedRandom() more robust [wb, 2009-10-06]
 * @changes    1.0.0b6   Changed ::symmetricKeyEncrypt() to throw an fValidationException when the $secret_key is less than 8 characters [wb, 2009-09-30]
 * @changes    1.0.0b5   Fixed a bug where some windows machines would throw an exception when generating random strings or numbers [wb, 2009-06-09]
 * @changes    1.0.0b4   Updated for new fCore API [wb, 2009-02-16]
 * @changes    1.0.0b3   Changed @ error suppression operator to `error_reporting()` calls [wb, 2009-01-26]
 * @changes    1.0.0b2   Backwards compatibility break - changed ::symmetricKeyEncrypt() to not encrypt the IV since we are using HMAC on it [wb, 2009-01-26]
 * @changes    1.0.0b    The initial implementation [wb, 2007-11-27]
 */
class fCryptography
{
    // The following constants allow for nice looking callbacks to static methods
    const checkPasswordHash   = 'fCryptography::checkPasswordHash';
    const hashHMAC            = 'fCryptography::hashHMAC';
    const hashPassword        = 'fCryptography::hashPassword';
    const publicKeyDecrypt    = 'fCryptography::publicKeyDecrypt';
    const publicKeyEncrypt    = 'fCryptography::publicKeyEncrypt';
    const publicKeySign       = 'fCryptography::publicKeySign';
    const publicKeyVerify     = 'fCryptography::publicKeyVerify';
    const random              = 'fCryptography::random';
    const randomString        = 'fCryptography::randomString';
    const symmetricKeyDecrypt = 'fCryptography::symmetricKeyDecrypt';
    const symmetricKeyEncrypt = 'fCryptography::symmetricKeyEncrypt';


    /**
     * Checks a password against a hash created with ::hashPassword()
     * 
     * @param  string $password  The password to check
     * @param  string $hash      The hash to check against
     * @return boolean  If the password matches the hash
     */
    static public function checkPasswordHash($password, $hash)
    {
        $salt = substr($hash, 29, 10);

        if (self::hashWithSalt($password, $salt) == $hash) {
            return TRUE;
        }

        return FALSE;
    }


    /**
     * Create a private key resource based on a filename and password
     * 
     * @throws fValidationException  When the private key is invalid
     * 
     * @param  string $private_key_file  The path to a PEM-encoded private key
     * @param  string $password          The password for the private key
     * @return resource  The private key resource
     */
    static private function createPrivateKeyResource($private_key_file, $password)
    {
        if (!file_exists($private_key_file)) {
            throw new fProgrammerException(
                'The path to the PEM-encoded private key specified, %s, is not valid',
                $private_key_file
            );
        }
        if (!is_readable($private_key_file)) {
            throw new fEnvironmentException(
                'The PEM-encoded private key specified, %s, is not readable',
                $private_key_file
            );
        }

        $private_key          = file_get_contents($private_key_file);
        $private_key_resource = openssl_pkey_get_private($private_key, $password);

        if ($private_key_resource === FALSE) {
            throw new fValidationException(
                'The private key file specified, %s, does not appear to be a valid private key or the password provided is incorrect',
                $private_key_file
            );
        }

        return $private_key_resource;
    }


    /**
     * Create a public key resource based on a filename
     * 
     * @param  string $public_key_file  The path to an X.509 public key certificate
     * @return resource  The public key resource
     */
    static private function createPublicKeyResource($public_key_file)
    {
        if (!file_exists($public_key_file)) {
            throw new fProgrammerException(
                'The path to the X.509 certificate specified, %s, is not valid',
                $public_key_file
            );
        }
        if (!is_readable($public_key_file)) {
            throw new fEnvironmentException(
                'The X.509 certificate specified, %s, can not be read',
                $public_key_file
            );
        }

        $public_key = file_get_contents($public_key_file);
        $public_key_resource = openssl_pkey_get_public($public_key);

        if ($public_key_resource === FALSE) {
            throw new fProgrammerException(
                'The public key certificate specified, %s, does not appear to be a valid certificate',
                $public_key_file
            );
        }

        return $public_key_resource;
    }


    /**
     * Provides a pure PHP implementation of `hash_hmac()` for when the hash extension is not installed
     * 
     * @internal
     * 
     * @param  string $algorithm  The hashing algorithm to use: `'md5'` or `'sha1'`
     * @param  string $data       The data to create an HMAC for
     * @param  string $key        The key to generate the HMAC with 
     * @return string  The HMAC
     */
    static public function hashHMAC($algorithm, $data, $key)
    {
        if (function_exists('hash_hmac')) {
            return hash_hmac($algorithm, $data, $key);
        }

        // Algorithm from http://www.ietf.org/rfc/rfc2104.txt
        if (strlen($key) > 64) {
            $key = pack('H*', $algorithm($key));
        }
        $key  = str_pad($key, 64, "\x0");

        $ipad = str_repeat("\x36", 64);
        $opad = str_repeat("\x5C", 64);

        return $algorithm(($key ^ $opad) . pack('H*', $algorithm(($key ^ $ipad) . $data)));
    }


    /**
     * Hashes a password using a loop of sha1 hashes and a salt, making rainbow table attacks infeasible
     * 
     * @param  string $password  The password to hash
     * @return string  An 80 character string of the Flourish fingerprint, salt and hashed password
     */
    static public function hashPassword($password)
    {
        $salt = self::randomString(10);

        return self::hashWithSalt($password, $salt);
    }


    /**
     * Performs a large iteration of hashing a string with a salt
     * 
     * @param  string $source  The string to hash
     * @param  string $salt    The salt for the hash
     * @return string  An 80 character string of the Flourish fingerprint, salt and hashed password
     */
    static private function hashWithSalt($source, $salt)
    {
        $sha1 = sha1($salt . $source);
        for ($i = 0; $i < 1000; $i++) {
            $sha1 = sha1($sha1 . (($i % 2 == 0) ? $source : $salt));
        }

        return 'fCryptography::password_hash#' . $salt . '#' . $sha1;
    }


    /**
     * Decrypts ciphertext encrypted using public-key encryption via ::publicKeyEncrypt()
     * 
     * A public key (X.509 certificate) is required for encryption and a
     * private key (PEM) is required for decryption.
     * 
     * @throws fValidationException  When the ciphertext appears to be corrupted
     * 
     * @param  string $ciphertext        The content to be decrypted
     * @param  string $private_key_file  The path to a PEM-encoded private key
     * @param  string $password          The password for the private key
     * @return string  The decrypted plaintext
     */
    static public function publicKeyDecrypt($ciphertext, $private_key_file, $password)
    {
        self::verifyPublicKeyEnvironment();

        $private_key_resource = self::createPrivateKeyResource($private_key_file, $password);

        $elements = explode('#', $ciphertext);

        // We need to make sure this ciphertext came from here, otherwise we are gonna have issues decrypting it
        if (sizeof($elements) != 4 || $elements[0] != 'fCryptography::public') {
            throw new fProgrammerException(
                'The ciphertext provided does not appear to have been encrypted using %s',
                __CLASS__ . '::publicKeyEncrypt()'
            );
        }

        $encrypted_key = base64_decode($elements[1]);
        $ciphertext    = base64_decode($elements[2]);
        $provided_hmac = $elements[3];

        $plaintext = '';
        $result = openssl_open($ciphertext, $plaintext, $encrypted_key, $private_key_resource);
        openssl_free_key($private_key_resource);

        if ($result === FALSE) {
            throw new fEnvironmentException(
                'There was an unknown error decrypting the ciphertext provided'
            );
        }

        $hmac = self::hashHMAC('sha1', $encrypted_key . $ciphertext, $plaintext);

        // By verifying the HMAC we ensure the integrity of the data
        if ($hmac != $provided_hmac) {
            throw new fValidationException(
                'The ciphertext provided appears to have been tampered with or corrupted'
            );
        }

        return $plaintext;
    }


    /**
     * Encrypts the passed data using public key encryption via OpenSSL
     * 
     * A public key (X.509 certificate) is required for encryption and a
     * private key (PEM) is required for decryption.
     * 
     * @param  string $plaintext        The content to be encrypted
     * @param  string $public_key_file  The path to an X.509 public key certificate
     * @return string  A base-64 encoded result containing a Flourish fingerprint and suitable for decryption using ::publicKeyDecrypt()
     */
    static public function publicKeyEncrypt($plaintext, $public_key_file)
    {
        self::verifyPublicKeyEnvironment();

        $public_key_resource = self::createPublicKeyResource($public_key_file);

        $ciphertext     = '';
        $encrypted_keys = array();
        $result = openssl_seal($plaintext, $ciphertext, $encrypted_keys, array($public_key_resource));
        openssl_free_key($public_key_resource);

        if ($result === FALSE) {
            throw new fEnvironmentException(
                'There was an unknown error encrypting the plaintext provided'
            );
        }

        $hmac = self::hashHMAC('sha1', $encrypted_keys[0] . $ciphertext, $plaintext);

        return 'fCryptography::public#' . base64_encode($encrypted_keys[0]) . '#' . base64_encode($ciphertext) . '#' . $hmac;
    }


    /**
     * Creates a signature for plaintext to allow verification of the creator
     * 
     * A private key (PEM) is required for signing and a public key
     * (X.509 certificate) is required for verification.
     * 
     * @throws fValidationException  When the private key is invalid
     * 
     * @param  string $plaintext         The content to be signed
     * @param  string $private_key_file  The path to a PEM-encoded private key
     * @param  string $password          The password for the private key
     * @return string  The base64-encoded signature suitable for verification using ::publicKeyVerify()
     */
    static public function publicKeySign($plaintext, $private_key_file, $password)
    {
        self::verifyPublicKeyEnvironment();

        $private_key_resource = self::createPrivateKeyResource($private_key_file, $password);

        $result = openssl_sign($plaintext, $signature, $private_key_resource);
        openssl_free_key($private_key_resource);

        if (!$result) {
            throw new fEnvironmentException(
                'There was an unknown error signing the plaintext'
            );
        }

        return base64_encode($signature);
    }


    /**
     * Checks a signature for plaintext to verify the creator - works with ::publicKeySign()
     * 
     * A private key (PEM) is required for signing and a public key
     * (X.509 certificate) is required for verification.
     * 
     * @param  string $plaintext         The content to check
     * @param  string $signature         The base64-encoded signature for the plaintext
     * @param  string $public_key_file   The path to an X.509 public key certificate
     * @return boolean  If the public key file is the public key of the user who signed the plaintext
     */
    static public function publicKeyVerify($plaintext, $signature, $public_key_file)
    {
        self::verifyPublicKeyEnvironment();

        $public_key_resource = self::createPublicKeyResource($public_key_file);

        $result = openssl_verify($plaintext, base64_decode($signature), $public_key_resource);
        openssl_free_key($public_key_resource);

        if ($result === -1) {
            throw new fEnvironmentException(
                'There was an unknown error verifying the plaintext and signature against the public key specified'
            );
        }

        return ($result === 1) ? TRUE : FALSE;
    }


    /**
     * Generates a random number using [http://php.net/mt_rand mt_rand()] after ensuring a good PRNG seed
     * 
     * @param  integer $min  The minimum number to return
     * @param  integer $max  The maximum number to return
     * @return integer  The psuedo-random number
     */
    static public function random($min=NULL, $max=NULL)
    {
        self::seedRandom();
        if ($min !== NULL || $max !== NULL) {
            return mt_rand($min, $max);
        }
        return mt_rand();
    }


    /**
     * Returns a random string of the type and length specified
     * 
     * @param  integer $length  The length of string to return
     * @param  string  $type    The type of string to return: `'alphanumeric'`, `'alpha'`, `'numeric'`, or `'hexadecimal'`
     * @return string  A random string of the type and length specified
     */
    static public function randomString($length, $type='alphanumeric')
    {
        if ($length < 1) {
            throw new fProgrammerException(
                'The length specified, %1$s, is less than the minimum of %2$s',
                $length,
                1
            );
        }

        switch ($type) {
            case 'base64':
                $alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/';
                break;

            case 'alphanumeric':
                $alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
                break;

            case 'alpha':
                $alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
                break;

            case 'numeric':
                $alphabet = '0123456789';
                break;

            case 'hexadecimal':
                $alphabet = 'abcdef0123456789';
                break;

            default:
                throw new fProgrammerException(
                    'The type specified, %1$s, is invalid. Must be one of: %2$s.',
                    $type,
                    join(', ', array('alphanumeric', 'alpha', 'numeric', 'hexadecimal'))
                );
        }

        $alphabet_length = strlen($alphabet);
        $output = '';

        for ($i = 0; $i < $length; $i++) {
            $output .= $alphabet[self::random(0, $alphabet_length-1)];
        }

        return $output;
    }


    /**
     * Makes sure that the PRNG has been seeded with a fairly secure value
     * 
     * @return void
     */
    static private function seedRandom()
    {
        static $seeded = FALSE;

        if ($seeded) {
            return;
        }

        fCore::startErrorCapture(E_WARNING);

        $bytes = NULL;

        // On linux/unix/solaris we should be able to use /dev/urandom
        if (!fCore::checkOS('windows') && $handle = fopen('/dev/urandom', 'rb')) {
            $bytes = fread($handle, 4);
            fclose($handle);

        // On windows we should be able to use the Cryptographic Application Programming Interface COM object
        } elseif (fCore::checkOS('windows') && class_exists('COM', FALSE)) {
            try {
                // This COM object no longer seems to work on PHP 5.2.9+, no response on the bug report yet
                $capi  = new COM('CAPICOM.Utilities.1');
                $bytes = base64_decode($capi->getrandom(4, 0));
                unset($capi);
            } catch (Exception $e) { }
        }

        // If we could not use the OS random number generators we get some of the most unique info we can        
        if (!$bytes) {
            $string = microtime(TRUE) . uniqid('', TRUE) . join('', stat(__FILE__)) . disk_free_space(dirname(__FILE__));
            $bytes  = substr(pack('H*', md5($string)), 0, 4);
        }

        fCore::stopErrorCapture();

        $seed = (int) (base_convert(bin2hex($bytes), 16, 10) - 2147483647);

        mt_srand($seed);

        $seeded = TRUE;
    }


    /**
     * Decrypts ciphertext encrypted using symmetric-key encryption via ::symmetricKeyEncrypt()
     * 
     * Since this is symmetric-key cryptography, the same key is used for
     * encryption and decryption.
     * 
     * @throws fValidationException  When the ciphertext appears to be corrupted
     * 
     * @param  string $ciphertext  The content to be decrypted
     * @param  string $secret_key  The secret key to use for decryption
     * @return string  The decrypted plaintext
     */
    static public function symmetricKeyDecrypt($ciphertext, $secret_key)
    {
        $elements = explode('#', $ciphertext);

        // We need to make sure this ciphertext came from here, otherwise we are gonna have issues decrypting it
        if (sizeof($elements) == 4 || $elements[0] == 'fCryptography::symmetric' || $elements[0] == 'fCryptography::symmetric-php') {} else {
            throw new fProgrammerException(
                'The ciphertext provided does not appear to have been encrypted using %s',
                __CLASS__ . '::symmetricKeyEncrypt()'
            );
        }

        $iv            = base64_decode($elements[1]);
        $ciphertext    = base64_decode($elements[2]);
        $provided_hmac = $elements[3];

        $hmac = self::hashHMAC('sha1', $iv . '#' . $ciphertext, $secret_key);

        // By verifying the HMAC we ensure the integrity of the data
        if ($hmac != $provided_hmac) {
            throw new fValidationException(
                'The ciphertext provided appears to have been tampered with or corrupted'
            );
        }

        // This code uses the Rijndael cipher with a 192 bit block size and a 256 bit key in cipher feedback mode

        $key = substr(sha1($secret_key), 0, 32);

        if (class_exists('Crypt_Rijndael', false) && $elements[0] == 'fCryptography::symmetric-php') {
            // Initialize Rijndael
            $crypt = new Crypt_Rijndael(CRYPT_RIJNDAEL_MODE_CFB);
            $crypt->setKeyLength(256);
            $crypt->setBlockLength(24);
            $crypt->disablePadding();

            // Set key and iv
            $crypt->setKey($key);
            $crypt->setIV($iv);

            // Main decryption
            $plaintext = $crypt->decrypt($ciphertext);

            // Clean up
            unset($crypt);
        }
        elseif ($elements[0] == 'fCryptography::symmetric') {
            self::verifySymmetricKeyEnvironment();
            // Set up the main decryption, we are gonna use AES-192 (also know as rijndael-192) in cipher feedback mode
            $module   = mcrypt_module_open('rijndael-192', '', 'cfb', '');
            mcrypt_generic_init($module, $key, $iv);

            fCore::startErrorCapture(E_WARNING);
            $plaintext = mdecrypt_generic($module, $ciphertext);
            fCore::stopErrorCapture();

            mcrypt_generic_deinit($module);
            mcrypt_module_close($module);
        }
        else {
            if ($elements[0] == 'fCryptography::symmetric') {
                throw new fProgrammerException(
                    'The ciphertext provided cannot be decrypted because the required PHP extension %s is not installed',
                    'mcrypt'
                );
            }
            else {
                throw new fProgrammerException(
                    'The ciphertext provided cannot be decrypted because the required PHP library %s is not available',
                    'PHPSecLib (Crypt/Rijndael)'
                );
            }
        }

        return $plaintext;
    }


    /**
     * Encrypts the passed data using symmetric-key encryption
     *
     * Since this is symmetric-key cryptography, the same key is used for
     * encryption and decryption.
     * 
     * @throws fValidationException  When the $secret_key is less than 8 characters long
     *  
     * @param  string $plaintext   The content to be encrypted
     * @param  string $secret_key  The secret key to use for encryption - must be at least 8 characters
     * @return string  An encrypted and base-64 encoded result containing a Flourish fingerprint and suitable for decryption using ::symmetricKeyDecrypt()
     */
    static public function symmetricKeyEncrypt($plaintext, $secret_key)
    {
        if (strlen($secret_key) < 8) {
            throw new fValidationException(
                'The secret key specified does not meet the minimum requirement of being at least %s characters long',
                8
            );
        }

        // This code uses the Rijndael cipher with a 192 bit block size and a
        // 256 bit key in cipher feedback mode. Cipher feedback mode is chosen
        // because no extra padding is added, ensuring we always get the exact
        // same plaintext out of the decrypt method

        $key = substr(sha1($secret_key), 0, 32);
        $iv  = base64_decode(self::randomString(32, 'base64'));

        if (class_exists('Crypt_Rijndael', false)) {
            $phpseclib = true;
            // Initialize Rijndael
            $crypt = new Crypt_Rijndael(CRYPT_RIJNDAEL_MODE_CFB);
            $crypt->setKeyLength(256);
            $crypt->setBlockLength(24);
            $crypt->disablePadding();

            // Set key and iv
            $crypt->setKey($key);
            $crypt->setIV($iv);

            // Main encryption
            $ciphertext = $crypt->encrypt($plaintext);

            // Clean up
            unset($crypt);
        }
        else {
            $phpseclib = false;
            self::verifySymmetricKeyEnvironment();
            $module   = mcrypt_module_open('rijndael-192', '', 'cfb', '');


            // Finish the main encryption
            mcrypt_generic_init($module, $key, $iv);

            fCore::startErrorCapture(E_WARNING);
            $ciphertext = mcrypt_generic($module, $plaintext);
            fCore::stopErrorCapture();

            // Clean up the main encryption
            mcrypt_generic_deinit($module);
            mcrypt_module_close($module);
        }

        // Here we are generating the HMAC for the encrypted data to ensure data integrity
        $hmac = self::hashHMAC('sha1', $iv . '#' . $ciphertext, $secret_key);

        // All of the data is then encoded using base64 to prevent issues with character sets
        $encoded_iv         = base64_encode($iv);
        $encoded_ciphertext = base64_encode($ciphertext);

        // Indicate in the resulting encrypted data what the encryption tool was
        $return  = 'fCryptography::symmetric';
        $return .= $phpseclib ? '-php' : '';
        $return .='#' . $encoded_iv . '#' . $encoded_ciphertext . '#' . $hmac;

        return $return;
    }


    /**
     * Makes sure the required PHP extensions and library versions are all correct
     * 
     * @return void
     */
    static private function verifyPublicKeyEnvironment()
    {
        if (!extension_loaded('openssl')) {
            throw new fEnvironmentException(
                'The PHP %s extension is required, however is does not appear to be loaded',
                'openssl'
            );
        }
    }


    /**
     * Makes sure the required PHP extensions and library versions are all correct
     * 
     * @return void
     */
    static private function verifySymmetricKeyEnvironment()
    {
        if (!extension_loaded('mcrypt')) {
            throw new fEnvironmentException(
                'The PHP %s extension is required, however is does not appear to be loaded',
                'mcrypt'
            );
        }
        if (!function_exists('mcrypt_module_open')) {
            throw new fEnvironmentException(
                'The cipher used, %1$s (also known as %2$s), requires libmcrypt version 2.4.x or newer. The version installed does not appear to meet this requirement.',
                'AES-192',
                'rijndael-192'
            );
        }
        if (!in_array('rijndael-192', mcrypt_list_algorithms())) {
            throw new fEnvironmentException(
                'The cipher used, %1$s (also known as %2$s), does not appear to be supported by the installed version of libmcrypt',
                'AES-192',
                'rijndael-192'
            );
        }
    }


    /**
     * Forces use as a static class
     * 
     * @return fSecurity
     */
    private function __construct() { }
}



/**
 * Copyright (c) 2007-2010 Will Bond <[email protected]>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

<?php
fCRUD::makeForm(string $orm_class, string $post_url, string $method = 'post', array $field_type_overrides = array(), array $unwanted_fields = array());
fCRUD::registerFormFieldCallback(string $orm_class_or_star, string $field_type, string $callback);
fCRUD::makeTableForm(string $orm_class, string $post_url, string $method = 'post', array $these_fields_only = NULL);
fCRUD::registerTableFormCallback(string $orm_class_or_star, string $column_name, string|array $callback, array $callback_args = array());

<?php
$html = fCRUD::makeForm($orm_class, '/place-to-post');

function cb($html, $attr = array()) {
  return '<div class="form-textfield-container"><input type="type" name="'.$attr['name'].'"></div>';
}
// Register a callback for all textfields rendered
fCRUD::registerFormFieldCallback('*', 'textfield', 'cb');

// Override some column types
$html = fCRUD::makeForm($orm_class, array('email_address' => 'email', 'user_password' => 'password'));

// Table with checkboxes
$html = fCRUD::makeTableForm($orm_class);

// Table with checkboxes, only the selected columns, callbacks, 2 signatures
fCrud::registerTableFormCallback($orm_class, 'date_created', array($fdate_obj, 'format'), array('U'));
$html = fCRUD::makeTableForm($orm_class, '/place-to-post', 'post', array('name', 'date_created'));

ob_start();
    include $path;
    $minified_path = ob_get_clean();
    $minified_path = trim($this->minify($minified_path, $type));
    file_put_contents($path_cache_file, $minified_path);

$template = new fTemplating();
    $template->enableMinification('development', $cache_directory);
    $template->enableGlobalPHP();

/*     * ****************************************** */
    /* Fonction: ImageCreateFromBMP              */
    /* Author:   DHKold                          */
    /* Contact:  [email protected]                */
    /* Date:     The 15th of June 2005           */
    /* Version:  2.0B                            */
    /*     * ****************************************** */

    public static function ImageCreateFromBMP($filename) {
        // open file in binary mode
        if (!$f1 = fopen($filename, "rb"))
            return FALSE;

        //1 : get headers
        $FILE = unpack("vfile_type/Vfile_size/Vreserved/Vbitmap_offset", fread($f1, 14));
        if ($FILE['file_type'] != 19778)
            return FALSE;

        //2 : get contents
        $BMP = unpack('Vheader_size/Vwidth/Vheight/vplanes/vbits_per_pixel' .
                        '/Vcompression/Vsize_bitmap/Vhoriz_resolution' .
                        '/Vvert_resolution/Vcolors_used/Vcolors_important', fread($f1, 40));
        $BMP['colors'] = pow(2, $BMP['bits_per_pixel']);
        if ($BMP['size_bitmap'] == 0)
            $BMP['size_bitmap'] = $FILE['file_size'] - $FILE['bitmap_offset'];
        $BMP['bytes_per_pixel'] = $BMP['bits_per_pixel'] / 8;
        $BMP['bytes_per_pixel2'] = ceil($BMP['bytes_per_pixel']);
        $BMP['decal'] = ($BMP['width'] * $BMP['bytes_per_pixel'] / 4);
        $BMP['decal'] -= floor($BMP['width'] * $BMP['bytes_per_pixel'] / 4);
        $BMP['decal'] = 4 - (4 * $BMP['decal']);
        if ($BMP['decal'] == 4)
            $BMP['decal'] = 0;

        //3 : get color palette
        $PALETTE = array();
        if ($BMP['colors'] < 16777216) {
            $PALETTE = unpack('V' . $BMP['colors'], fread($f1, $BMP['colors'] * 4));
        }

        //4 : create image
        $IMG = fread($f1, $BMP['size_bitmap']);
        $VIDE = chr(0);

        $res = imagecreatetruecolor($BMP['width'], $BMP['height']);
        $P = 0;
        $Y = $BMP['height'] - 1;
        while ($Y >= 0) {
            $X = 0;
            while ($X < $BMP['width']) {
                if ($BMP['bits_per_pixel'] == 24)
                    $COLOR = unpack("V", substr($IMG, $P, 3) . $VIDE);
                elseif ($BMP['bits_per_pixel'] == 16) {
                    $COLOR = unpack("n", substr($IMG, $P, 2));
                    $COLOR[1] = $PALETTE[$COLOR[1] + 1];
                } elseif ($BMP['bits_per_pixel'] == 8) {
                    $COLOR = unpack("n", $VIDE . substr($IMG, $P, 1));
                    $COLOR[1] = $PALETTE[$COLOR[1] + 1];
                } elseif ($BMP['bits_per_pixel'] == 4) {
                    $COLOR = unpack("n", $VIDE . substr($IMG, floor($P), 1));
                    if (($P * 2) % 2 == 0)
                        $COLOR[1] = ($COLOR[1] >> 4); else
                        $COLOR[1] = ($COLOR[1] & 0x0F);
                    $COLOR[1] = $PALETTE[$COLOR[1] + 1];
                }
                elseif ($BMP['bits_per_pixel'] == 1) {
                    $COLOR = unpack("n", $VIDE . substr($IMG, floor($P), 1));
                    if (($P * 8) % 8 == 0)
                        $COLOR[1] = $COLOR[1] >> 7;
                    elseif (($P * 8) % 8 == 1)
                        $COLOR[1] = ($COLOR[1] & 0x40) >> 6;
                    elseif (($P * 8) % 8 == 2)
                        $COLOR[1] = ($COLOR[1] & 0x20) >> 5;
                    elseif (($P * 8) % 8 == 3)
                        $COLOR[1] = ($COLOR[1] & 0x10) >> 4;
                    elseif (($P * 8) % 8 == 4)
                        $COLOR[1] = ($COLOR[1] & 0x8) >> 3;
                    elseif (($P * 8) % 8 == 5)
                        $COLOR[1] = ($COLOR[1] & 0x4) >> 2;
                    elseif (($P * 8) % 8 == 6)
                        $COLOR[1] = ($COLOR[1] & 0x2) >> 1;
                    elseif (($P * 8) % 8 == 7)
                        $COLOR[1] = ($COLOR[1] & 0x1);
                    $COLOR[1] = $PALETTE[$COLOR[1] + 1];
                }
                else
                    return FALSE;
                imagesetpixel($res, $X, $Y, $COLOR[1]);
                $X++;
                $P += $BMP['bytes_per_pixel'];
            }
            $Y--;
            $P+=$BMP['decal'];
        }

        // close file
        fclose($f1);

        return $res;
    }

fJSON::encodeWithPadding($data, $callback_name);