nilsteampassnet / TeamPass

includes/libraries/Database/Meekrodb/db.class.php

Indentation +385 added lines, -385 removed lines

@@ -18,33 +18,33 @@ 
 
 
 class DB {
-  // initial connection
-  public static $dbName = '';
-  public static $user = '';
-  public static $password = '';
-  public static $host = 'localhost';
-  public static $port = null;
-  public static $encoding = 'utf8';
-
-  // configure workings
-  public static $param_char = '%';
-  public static $named_param_seperator = '_';
-  public static $success_handler = false;
-  public static $error_handler = true;
-  public static $throw_exception_on_error = false;
-  public static $nonsql_error_handler = null;
-  public static $throw_exception_on_nonsql_error = false;
-  public static $nested_transactions = false;
-  public static $usenull = true;
-
-  // internal
-  protected static $mdb = null;
-
-  public static function getMDB() {
+    // initial connection
+    public static $dbName = '';
+    public static $user = '';
+    public static $password = '';
+    public static $host = 'localhost';
+    public static $port = null;
+    public static $encoding = 'utf8';
+
+    // configure workings
+    public static $param_char = '%';
+    public static $named_param_seperator = '_';
+    public static $success_handler = false;
+    public static $error_handler = true;
+    public static $throw_exception_on_error = false;
+    public static $nonsql_error_handler = null;
+    public static $throw_exception_on_nonsql_error = false;
+    public static $nested_transactions = false;
+    public static $usenull = true;
+
+    // internal
+    protected static $mdb = null;
+
+    public static function getMDB() {
     $mdb = DB::$mdb;
 
     if ($mdb === null) {
-      $mdb = DB::$mdb = new MeekroDB();
+        $mdb = DB::$mdb = new MeekroDB();
     }
 
     if ($mdb->param_char !== DB::$param_char) $mdb->param_char = DB::$param_char;
@@ -58,91 +58,91 @@ 
     if ($mdb->usenull !== DB::$usenull) $mdb->usenull = DB::$usenull;
 
     return $mdb;
-  }
-
-  public static function get() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'get'), $args); }
-  public static function disconnect() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'disconnect'), $args); }
-  public static function query() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'query'), $args); }
-  public static function queryFirstRow() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstRow'), $args); }
-  public static function queryOneRow() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneRow'), $args); }
-  public static function queryAllLists() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryAllLists'), $args); }
-  public static function queryFullColumns() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFullColumns'), $args); }
-  public static function queryFirstList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstList'), $args); }
-  public static function queryOneList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneList'), $args); }
-  public static function queryFirstColumn() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstColumn'), $args); }
-  public static function queryOneColumn() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneColumn'), $args); }
-  public static function queryFirstField() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstField'), $args); }
-  public static function queryOneField() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneField'), $args); }
-  public static function queryRaw() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryRaw'), $args); }
-  public static function queryRawUnbuf() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryRawUnbuf'), $args); }
-
-  public static function insert() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insert'), $args); }
-  public static function insertIgnore() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertIgnore'), $args); }
-  public static function insertUpdate() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertUpdate'), $args); }
-  public static function replace() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'replace'), $args); }
-  public static function update() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'update'), $args); }
-  public static function delete() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'delete'), $args); }
-
-  public static function insertId() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertId'), $args); }
-  public static function count() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'count'), $args); }
-  public static function affectedRows() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'affectedRows'), $args); }
-
-  public static function useDB() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'useDB'), $args); }
-  public static function startTransaction() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'startTransaction'), $args); }
-  public static function commit() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'commit'), $args); }
-  public static function rollback() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'rollback'), $args); }
-  public static function tableList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'tableList'), $args); }
-  public static function columnList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'columnList'), $args); }
-
-  public static function sqlEval() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'sqlEval'), $args); }
-  public static function nonSQLError() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'nonSQLError'), $args); }
-
-  public static function serverVersion() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'serverVersion'), $args); }
-  public static function transactionDepth() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'transactionDepth'), $args); }
-
-
-  public static function debugMode($handler = true) {
+    }
+
+    public static function get() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'get'), $args); }
+    public static function disconnect() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'disconnect'), $args); }
+    public static function query() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'query'), $args); }
+    public static function queryFirstRow() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstRow'), $args); }
+    public static function queryOneRow() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneRow'), $args); }
+    public static function queryAllLists() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryAllLists'), $args); }
+    public static function queryFullColumns() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFullColumns'), $args); }
+    public static function queryFirstList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstList'), $args); }
+    public static function queryOneList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneList'), $args); }
+    public static function queryFirstColumn() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstColumn'), $args); }
+    public static function queryOneColumn() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneColumn'), $args); }
+    public static function queryFirstField() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstField'), $args); }
+    public static function queryOneField() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneField'), $args); }
+    public static function queryRaw() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryRaw'), $args); }
+    public static function queryRawUnbuf() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryRawUnbuf'), $args); }
+
+    public static function insert() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insert'), $args); }
+    public static function insertIgnore() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertIgnore'), $args); }
+    public static function insertUpdate() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertUpdate'), $args); }
+    public static function replace() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'replace'), $args); }
+    public static function update() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'update'), $args); }
+    public static function delete() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'delete'), $args); }
+
+    public static function insertId() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertId'), $args); }
+    public static function count() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'count'), $args); }
+    public static function affectedRows() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'affectedRows'), $args); }
+
+    public static function useDB() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'useDB'), $args); }
+    public static function startTransaction() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'startTransaction'), $args); }
+    public static function commit() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'commit'), $args); }
+    public static function rollback() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'rollback'), $args); }
+    public static function tableList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'tableList'), $args); }
+    public static function columnList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'columnList'), $args); }
+
+    public static function sqlEval() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'sqlEval'), $args); }
+    public static function nonSQLError() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'nonSQLError'), $args); }
+
+    public static function serverVersion() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'serverVersion'), $args); }
+    public static function transactionDepth() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'transactionDepth'), $args); }
+
+
+    public static function debugMode($handler = true) {
     DB::$success_handler = $handler;
-  }
+    }
 
-  public function version() {
+    public function version() {
     return $this->version_info();
-  }
+    }
 
 }
 
 
 class MeekroDB {
-  // initial connection
-  public $dbName = '';
-  public $user = '';
-  public $password = '';
-  public $host = 'localhost';
-  public $port = null;
-  public $encoding = 'latin1';
-
-  // configure workings
-  public $param_char = '%';
-  public $named_param_seperator = '_';
-  public $success_handler = false;
-  public $error_handler = true;
-  public $throw_exception_on_error = false;
-  public $nonsql_error_handler = null;
-  public $throw_exception_on_nonsql_error = false;
-  public $nested_transactions = false;
-  public $usenull = true;
-
-  // internal
-  public $internal_mysql = null;
-  public $server_info = null;
-  public $insert_id = 0;
-  public $num_rows = 0;
-  public $affected_rows = 0;
-  public $current_db = null;
-  public $nested_transactions_count = 0;
-
-
-  public function __construct($host=null, $user=null, $password=null, $dbName=null, $port=null, $encoding=null) {
+    // initial connection
+    public $dbName = '';
+    public $user = '';
+    public $password = '';
+    public $host = 'localhost';
+    public $port = null;
+    public $encoding = 'latin1';
+
+    // configure workings
+    public $param_char = '%';
+    public $named_param_seperator = '_';
+    public $success_handler = false;
+    public $error_handler = true;
+    public $throw_exception_on_error = false;
+    public $nonsql_error_handler = null;
+    public $throw_exception_on_nonsql_error = false;
+    public $nested_transactions = false;
+    public $usenull = true;
+
+    // internal
+    public $internal_mysql = null;
+    public $server_info = null;
+    public $insert_id = 0;
+    public $num_rows = 0;
+    public $affected_rows = 0;
+    public $current_db = null;
+    public $nested_transactions_count = 0;
+
+
+    public function __construct($host=null, $user=null, $password=null, $dbName=null, $port=null, $encoding=null) {
     if ($host === null) $host = DB::$host;
     if ($user === null) $user = DB::$user;
     if ($password === null) $password = DB::$password;
@@ -156,131 +156,131 @@ 
     $this->dbName = $dbName;
     $this->port = $port;
     $this->encoding = $encoding;
-  }
+    }
 
-  public function get() {
+    public function get() {
     $mysql = $this->internal_mysql;
 
     if (!($mysql instanceof MySQLi)) {
-      if (! $this->port) $this->port = ini_get('mysqli.default_port');
-      $this->current_db = $this->dbName;
+        if (! $this->port) $this->port = ini_get('mysqli.default_port');
+        $this->current_db = $this->dbName;
       
-      $mysql = new mysqli($this->host, $this->user, $this->password, $this->dbName, $this->port);
+        $mysql = new mysqli($this->host, $this->user, $this->password, $this->dbName, $this->port);
 
-      if ($mysql->connect_error) {
+        if ($mysql->connect_error) {
         $this->nonSQLError('Unable to connect to MySQL server! Error: ' . $mysql->connect_error);
-      }
+        }
 
-      $mysql->set_charset($this->encoding);
-      $this->internal_mysql = $mysql;
-      $this->server_info = $mysql->server_info;
+        $mysql->set_charset($this->encoding);
+        $this->internal_mysql = $mysql;
+        $this->server_info = $mysql->server_info;
     }
 
     return $mysql;
-  }
+    }
 
-  public function disconnect() {
+    public function disconnect() {
     $mysqli = $this->internal_mysql;
     if ($mysqli instanceof MySQLi) {
-      if ($thread_id = $mysqli->thread_id) $mysqli->kill($thread_id);
-      $mysqli->close();
+        if ($thread_id = $mysqli->thread_id) $mysqli->kill($thread_id);
+        $mysqli->close();
     }
     $this->internal_mysql = null;
-  }
+    }
 
-  public function nonSQLError($message) {
+    public function nonSQLError($message) {
     if ($this->throw_exception_on_nonsql_error) {
-      $e = new MeekroDBException($message);
-      throw $e;
+        $e = new MeekroDBException($message);
+        throw $e;
     }
 
     $error_handler = is_callable($this->nonsql_error_handler) ? $this->nonsql_error_handler : 'meekrodb_error_handler';
 
     call_user_func($error_handler, array(
-      'type' => 'nonsql',
-      'error' => $message
+        'type' => 'nonsql',
+        'error' => $message
     ));
-  }
+    }
 
-  public function debugMode($handler = true) {
+    public function debugMode($handler = true) {
     $this->success_handler = $handler;
-  }
+    }
 
-  public function serverVersion() { $this->get(); return $this->server_info; }
-  public function transactionDepth() { return $this->nested_transactions_count; }
-  public function insertId() { return $this->insert_id; }
-  public function affectedRows() { return $this->affected_rows; }
-  public function count() { $args = func_get_args(); return call_user_func_array(array($this, 'numRows'), $args); }
-  public function numRows() { return $this->num_rows; }
+    public function serverVersion() { $this->get(); return $this->server_info; }
+    public function transactionDepth() { return $this->nested_transactions_count; }
+    public function insertId() { return $this->insert_id; }
+    public function affectedRows() { return $this->affected_rows; }
+    public function count() { $args = func_get_args(); return call_user_func_array(array($this, 'numRows'), $args); }
+    public function numRows() { return $this->num_rows; }
 
-  public function useDB() { $args = func_get_args(); return call_user_func_array(array($this, 'setDB'), $args); }
-  public function setDB($dbName) {
+    public function useDB() { $args = func_get_args(); return call_user_func_array(array($this, 'setDB'), $args); }
+    public function setDB($dbName) {
     $db = $this->get();
     if (! $db->select_db($dbName)) $this->nonSQLError("Unable to set database to $dbName");
     $this->current_db = $dbName;
-  }
+    }
 
 
-  public function startTransaction() {
+    public function startTransaction() {
     if ($this->nested_transactions && $this->serverVersion() < '5.5') {
-      return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion());
+        return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion());
     }
 
     if (!$this->nested_transactions || $this->nested_transactions_count == 0) {
-      $this->query('START TRANSACTION');
-      $this->nested_transactions_count = 1;
+        $this->query('START TRANSACTION');
+        $this->nested_transactions_count = 1;
     } else {
-      $this->query("SAVEPOINT LEVEL{$this->nested_transactions_count}");
-      $this->nested_transactions_count++;
+        $this->query("SAVEPOINT LEVEL{$this->nested_transactions_count}");
+        $this->nested_transactions_count++;
     }
 
     return $this->nested_transactions_count;
-  }
+    }
 
-  public function commit($all=false) {
+    public function commit($all=false) {
     if ($this->nested_transactions && $this->serverVersion() < '5.5') {
-      return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion());
+        return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion());
     }
 
     if ($this->nested_transactions && $this->nested_transactions_count > 0)
-      $this->nested_transactions_count--;
+        $this->nested_transactions_count--;
 
     if (!$this->nested_transactions || $all || $this->nested_transactions_count == 0) {
-      $this->nested_transactions_count = 0;
-      $this->query('COMMIT');
+        $this->nested_transactions_count = 0;
+        $this->query('COMMIT');
     } else {
-      $this->query("RELEASE SAVEPOINT LEVEL{$this->nested_transactions_count}");
+        $this->query("RELEASE SAVEPOINT LEVEL{$this->nested_transactions_count}");
     }
 
     return $this->nested_transactions_count;
-  }
+    }
 
-  public function rollback($all=false) {
+    public function rollback($all=false) {
     if ($this->nested_transactions && $this->serverVersion() < '5.5') {
-      return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion());
+        return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion());
     }
 
     if ($this->nested_transactions && $this->nested_transactions_count > 0)
-      $this->nested_transactions_count--;
+        $this->nested_transactions_count--;
 
     if (!$this->nested_transactions || $all || $this->nested_transactions_count == 0) {
-      $this->nested_transactions_count = 0;
-      $this->query('ROLLBACK');
+        $this->nested_transactions_count = 0;
+        $this->query('ROLLBACK');
     } else {
-      $this->query("ROLLBACK TO SAVEPOINT LEVEL{$this->nested_transactions_count}");
+        $this->query("ROLLBACK TO SAVEPOINT LEVEL{$this->nested_transactions_count}");
     }
 
     return $this->nested_transactions_count;
-  }
+    }
 
-  protected function formatTableName($table) {
+    protected function formatTableName($table) {
     $table = trim($table, '`');
 
     if (strpos($table, '.')) return implode('.', array_map(array($this, 'formatTableName'), explode('.', $table)));
     else return '`' . str_replace('`', '``', $table) . '`';
-  }
+    }
 
-  public function update() {
+    public function update() {
     $args = func_get_args();
     $table = array_shift($args);
     $params = array_shift($args);
@@ -292,95 +292,95 @@ 
     array_unshift($args, $table);
     array_unshift($args, $query);
     return call_user_func_array(array($this, 'query'), $args);
-  }
+    }
 
-  public function insertOrReplace($which, $table, $datas, $options=array()) {
+    public function insertOrReplace($which, $table, $datas, $options=array()) {
     $datas = unserialize(serialize($datas)); // break references within array
     $keys = $values = array();
 
     if (isset($datas[0]) && is_array($datas[0])) {
-      foreach ($datas as $datum) {
+        foreach ($datas as $datum) {
         ksort($datum);
         if (! $keys) $keys = array_keys($datum);
         $values[] = array_values($datum);
-      }
+        }
 
     } else {
-      $keys = array_keys($datas);
-      $values = array_values($datas);
+        $keys = array_keys($datas);
+        $values = array_values($datas);
     }
 
     if (isset($options['ignore']) && $options['ignore']) $which = 'INSERT IGNORE';
 
     if (isset($options['update']) && is_array($options['update']) && $options['update'] && strtolower($which) == 'insert') {
-      if (array_values($options['update']) !== $options['update']) {
+        if (array_values($options['update']) !== $options['update']) {
         return $this->query("INSERT INTO %b %lb VALUES %? ON DUPLICATE KEY UPDATE %?", $table, $keys, $values, $options['update']);
-      } else {
+        } else {
         $update_str = array_shift($options['update']);
         $query_param = array("INSERT INTO %b %lb VALUES %? ON DUPLICATE KEY UPDATE $update_str", $table, $keys, $values);
         $query_param = array_merge($query_param, $options['update']);
         return call_user_func_array(array($this, 'query'), $query_param);
-      }
+        }
 
     }
 
     return $this->query("%l INTO %b %lb VALUES %?", $which, $table, $keys, $values);
-  }
+    }
 
-  public function insert($table, $data) { return $this->insertOrReplace('INSERT', $table, $data); }
-  public function insertIgnore($table, $data) { return $this->insertOrReplace('INSERT', $table, $data, array('ignore' => true)); }
-  public function replace($table, $data) { return $this->insertOrReplace('REPLACE', $table, $data); }
+    public function insert($table, $data) { return $this->insertOrReplace('INSERT', $table, $data); }
+    public function insertIgnore($table, $data) { return $this->insertOrReplace('INSERT', $table, $data, array('ignore' => true)); }
+    public function replace($table, $data) { return $this->insertOrReplace('REPLACE', $table, $data); }
 
-  public function insertUpdate() {
+    public function insertUpdate() {
     $args = func_get_args();
     $table = array_shift($args);
     $data = array_shift($args);
 
     if (! isset($args[0])) { // update will have all the data of the insert
-      if (isset($data[0]) && is_array($data[0])) { //multiple insert rows specified -- failing!
+        if (isset($data[0]) && is_array($data[0])) { //multiple insert rows specified -- failing!
         $this->nonSQLError("Badly formatted insertUpdate() query -- you didn't specify the update component!");
-      }
+        }
 
-      $args[0] = $data;
+        $args[0] = $data;
     }
 
     if (is_array($args[0])) $update = $args[0];
     else $update = $args;
 
     return $this->insertOrReplace('INSERT', $table, $data, array('update' => $update));
-  }
+    }
 
-  public function delete() {
+    public function delete() {
     $args = func_get_args();
     $table = $this->formatTableName(array_shift($args));
     $where = array_shift($args);
     $buildquery = "DELETE FROM $table WHERE $where";
     array_unshift($args, $buildquery);
     return call_user_func_array(array($this, 'query'), $args);
-  }
+    }
 
-  public function sqleval() {
+    public function sqleval() {
     $args = func_get_args();
     $text = call_user_func_array(array($this, 'parseQueryParams'), $args);
     return new MeekroDBEval($text);
-  }
+    }
 
-  public function columnList($table) {
+    public function columnList($table) {
     return $this->queryOneColumn('Field', "SHOW COLUMNS FROM $table");
-  }
+    }
 
-  public function tableList($db = null) {
+    public function tableList($db = null) {
     if ($db) {
-      $olddb = $this->current_db;
-      $this->useDB($db);
+        $olddb = $this->current_db;
+        $this->useDB($db);
     }
 
     $result = $this->queryFirstColumn('SHOW TABLES');
     if (isset($olddb)) $this->useDB($olddb);
     return $result;
-  }
+    }
 
-  protected function preparseQueryParams() {
+    protected function preparseQueryParams() {
     $args = func_get_args();
     $sql = trim(strval(array_shift($args)));
     $args_all = $args;
@@ -391,32 +391,32 @@ 
     $named_seperator_length = strlen($this->named_param_seperator);
 
     $types = array(
-      $this->param_char . 'll', // list of literals
-      $this->param_char . 'ls', // list of strings
-      $this->param_char . 'l',  // literal
-      $this->param_char . 'li', // list of integers
-      $this->param_char . 'ld', // list of decimals
-      $this->param_char . 'lb', // list of backticks
-      $this->param_char . 'lt', // list of timestamps
-      $this->param_char . 's',  // string
-      $this->param_char . 'i',  // integer
-      $this->param_char . 'd',  // double / decimal
-      $this->param_char . 'b',  // backtick
-      $this->param_char . 't',  // timestamp
-      $this->param_char . '?',  // infer type
-      $this->param_char . 'ss'  // search string (like string, surrounded with %'s)
+        $this->param_char . 'll', // list of literals
+        $this->param_char . 'ls', // list of strings
+        $this->param_char . 'l',  // literal
+        $this->param_char . 'li', // list of integers
+        $this->param_char . 'ld', // list of decimals
+        $this->param_char . 'lb', // list of backticks
+        $this->param_char . 'lt', // list of timestamps
+        $this->param_char . 's',  // string
+        $this->param_char . 'i',  // integer
+        $this->param_char . 'd',  // double / decimal
+        $this->param_char . 'b',  // backtick
+        $this->param_char . 't',  // timestamp
+        $this->param_char . '?',  // infer type
+        $this->param_char . 'ss'  // search string (like string, surrounded with %'s)
     );
 
     // generate list of all MeekroDB variables in our query, and their position
     // in the form "offset => variable", sorted by offsets
     $posList = array();
     foreach ($types as $type) {
-      $lastPos = 0;
-      while (($pos = strpos($sql, $type, $lastPos)) !== false) {
+        $lastPos = 0;
+        while (($pos = strpos($sql, $type, $lastPos)) !== false) {
         $lastPos = $pos + 1;
         if (isset($posList[$pos]) && strlen($posList[$pos]) > strlen($type)) continue;
         $posList[$pos] = $type;
-      }
+        }
     }
 
     ksort($posList);
@@ -425,24 +425,24 @@ 
     $chunkyQuery = array(); // preparsed query
     $pos_adj = 0; // how much we've added or removed from the original sql string
     foreach ($posList as $pos => $type) {
-      $type = substr($type, $param_char_length); // variable, without % in front of it
-      $length_type = strlen($type) + $param_char_length; // length of variable w/o %
+        $type = substr($type, $param_char_length); // variable, without % in front of it
+        $length_type = strlen($type) + $param_char_length; // length of variable w/o %
 
-      $new_pos = $pos + $pos_adj; // position of start of variable
-      $new_pos_back = $new_pos + $length_type; // position of end of variable
-      $arg_number_length = 0; // length of any named or numbered parameter addition
+        $new_pos = $pos + $pos_adj; // position of start of variable
+        $new_pos_back = $new_pos + $length_type; // position of end of variable
+        $arg_number_length = 0; // length of any named or numbered parameter addition
 
-      // handle numbered parameters
-      if ($arg_number_length = strspn($sql, '0123456789', $new_pos_back)) {
+        // handle numbered parameters
+        if ($arg_number_length = strspn($sql, '0123456789', $new_pos_back)) {
         $arg_number = substr($sql, $new_pos_back, $arg_number_length);
         if (! array_key_exists($arg_number, $args_all)) $this->nonSQLError("Non existent argument reference (arg $arg_number): $sql");
 
         $arg = $args_all[$arg_number];
 
-      // handle named parameters
-      } else if (substr($sql, $new_pos_back, $named_seperator_length) == $this->named_param_seperator) {
+        // handle named parameters
+        } else if (substr($sql, $new_pos_back, $named_seperator_length) == $this->named_param_seperator) {
         $arg_number_length = strspn($sql, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_',
-          $new_pos_back + $named_seperator_length) + $named_seperator_length;
+            $new_pos_back + $named_seperator_length) + $named_seperator_length;
 
         $arg_number = substr($sql, $new_pos_back + $named_seperator_length, $arg_number_length - $named_seperator_length);
         if (count($args_all) != 1 || !is_array($args_all[0])) $this->nonSQLError("If you use named parameters, the second argument must be an array of parameters");
@@ -450,38 +450,38 @@ 
 
         $arg = $args_all[0][$arg_number];
 
-      } else {
+        } else {
         $arg_number = 0;
         $arg = array_shift($args);
-      }
+        }
 
-      if ($new_pos > 0) $chunkyQuery[] = substr($sql, 0, $new_pos);
+        if ($new_pos > 0) $chunkyQuery[] = substr($sql, 0, $new_pos);
 
-      if (is_object($arg) && ($arg instanceof WhereClause)) {
+        if (is_object($arg) && ($arg instanceof WhereClause)) {
         list($clause_sql, $clause_args) = $arg->textAndArgs();
         array_unshift($clause_args, $clause_sql);
         $preparsed_sql = call_user_func_array(array($this, 'preparseQueryParams'), $clause_args);
         $chunkyQuery = array_merge($chunkyQuery, $preparsed_sql);
-      } else {
+        } else {
         $chunkyQuery[] = array('type' => $type, 'value' => $arg);
-      }
+        }
 
-      $sql = substr($sql, $new_pos_back + $arg_number_length);
-      $pos_adj -= $new_pos_back + $arg_number_length;
+        $sql = substr($sql, $new_pos_back + $arg_number_length);
+        $pos_adj -= $new_pos_back + $arg_number_length;
     }
 
     if (strlen($sql) > 0) $chunkyQuery[] = $sql;
 
     return $chunkyQuery;
-  }
+    }
 
-  protected function escape($str) { return "'" . $this->get()->real_escape_string(strval($str)) . "'"; }
+    protected function escape($str) { return "'" . $this->get()->real_escape_string(strval($str)) . "'"; }
 
-  protected function sanitize($value) {
+    protected function sanitize($value) {
     if (is_object($value)) {
-      if ($value instanceof MeekroDBEval) return $value->text;
-      else if ($value instanceof DateTime) return $this->escape($value->format('Y-m-d H:i:s'));
-      else return '';
+        if ($value instanceof MeekroDBEval) return $value->text;
+        else if ($value instanceof DateTime) return $this->escape($value->format('Y-m-d H:i:s'));
+        else return '';
     }
 
     if (is_null($value)) return $this->usenull ? 'NULL' : "''";
@@ -490,33 +490,33 @@ 
     else if (is_float($value)) return $value;
 
     else if (is_array($value)) {
-      // non-assoc array?
-      if (array_values($value) === $value) {
+        // non-assoc array?
+        if (array_values($value) === $value) {
         if (is_array($value[0])) return implode(', ', array_map(array($this, 'sanitize'), $value));
         else return '(' . implode(', ', array_map(array($this, 'sanitize'), $value)) . ')';
-      }
+        }
 
-      $pairs = array();
-      foreach ($value as $k => $v) {
+        $pairs = array();
+        foreach ($value as $k => $v) {
         $pairs[] = $this->formatTableName($k) . '=' . $this->sanitize($v);
-      }
+        }
 
-      return implode(', ', $pairs);
+        return implode(', ', $pairs);
     }
     else return $this->escape($value);
-  }
+    }
 
-  protected function parseTS($ts) {
+    protected function parseTS($ts) {
     if (is_string($ts)) return date('Y-m-d H:i:s', strtotime($ts));
     else if (is_object($ts) && ($ts instanceof DateTime)) return $ts->format('Y-m-d H:i:s');
-  }
+    }
 
-  protected function intval($var) {
+    protected function intval($var) {
     if (PHP_INT_SIZE == 8) return intval($var);
     return floor(doubleval($var));
-  }
+    }
 
-  protected function parseQueryParams() {
+    protected function parseQueryParams() {
     $args = func_get_args();
     $chunkyQuery = call_user_func_array(array($this, 'preparseQueryParams'), $args);
 
@@ -524,57 +524,57 @@ 
     $array_types = array('ls', 'li', 'ld', 'lb', 'll', 'lt');
 
     foreach ($chunkyQuery as $chunk) {
-      if (is_string($chunk)) {
+        if (is_string($chunk)) {
         $query .= $chunk;
         continue;
-      }
+        }
 
-      $type = $chunk['type'];
-      $arg = $chunk['value'];
-      $result = '';
+        $type = $chunk['type'];
+        $arg = $chunk['value'];
+        $result = '';
 
-      if ($type != '?') {
+        if ($type != '?') {
         $is_array_type = in_array($type, $array_types, true);
         if ($is_array_type && !is_array($arg)) $this->nonSQLError("Badly formatted SQL query: Expected array, got scalar instead!");
         else if (!$is_array_type && is_array($arg)) $this->nonSQLError("Badly formatted SQL query: Expected scalar, got array instead!");
-      }
+        }
 
-      if ($type == 's') $result = $this->escape($arg);
-      else if ($type == 'i') $result = $this->intval($arg);
-      else if ($type == 'd') $result = doubleval($arg);
-      else if ($type == 'b') $result = $this->formatTableName($arg);
-      else if ($type == 'l') $result = $arg;
-      else if ($type == 'ss') $result = $this->escape("%" . str_replace(array('%', '_'), array('\%', '\_'), $arg) . "%");
-      else if ($type == 't') $result = $this->escape($this->parseTS($arg));
+        if ($type == 's') $result = $this->escape($arg);
+        else if ($type == 'i') $result = $this->intval($arg);
+        else if ($type == 'd') $result = doubleval($arg);
+        else if ($type == 'b') $result = $this->formatTableName($arg);
+        else if ($type == 'l') $result = $arg;
+        else if ($type == 'ss') $result = $this->escape("%" . str_replace(array('%', '_'), array('\%', '\_'), $arg) . "%");
+        else if ($type == 't') $result = $this->escape($this->parseTS($arg));
 
-      else if ($type == 'ls') $result = array_map(array($this, 'escape'), $arg);
-      else if ($type == 'li') $result = array_map(array($this, 'intval'), $arg);
-      else if ($type == 'ld') $result = array_map('doubleval', $arg);
-      else if ($type == 'lb') $result = array_map(array($this, 'formatTableName'), $arg);
-      else if ($type == 'll') $result = $arg;
-      else if ($type == 'lt') $result = array_map(array($this, 'escape'), array_map(array($this, 'parseTS'), $arg));
+        else if ($type == 'ls') $result = array_map(array($this, 'escape'), $arg);
+        else if ($type == 'li') $result = array_map(array($this, 'intval'), $arg);
+        else if ($type == 'ld') $result = array_map('doubleval', $arg);
+        else if ($type == 'lb') $result = array_map(array($this, 'formatTableName'), $arg);
+        else if ($type == 'll') $result = $arg;
+        else if ($type == 'lt') $result = array_map(array($this, 'escape'), array_map(array($this, 'parseTS'), $arg));
 
-      else if ($type == '?') $result = $this->sanitize($arg);
+        else if ($type == '?') $result = $this->sanitize($arg);
 
-      else $this->nonSQLError("Badly formatted SQL query: Invalid MeekroDB param $type");
+        else $this->nonSQLError("Badly formatted SQL query: Invalid MeekroDB param $type");
 
-      if (is_array($result)) $result = '(' . implode(',', $result) . ')';
+        if (is_array($result)) $result = '(' . implode(',', $result) . ')';
 
-      $query .= $result;
+        $query .= $result;
     }
 
     return $query;
-  }
+    }
 
-  protected function prependCall($function, $args, $prepend) { array_unshift($args, $prepend); return call_user_func_array($function, $args); }
-  public function query() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'assoc'); }
-  public function queryAllLists() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'list'); }
-  public function queryFullColumns() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'full'); }
+    protected function prependCall($function, $args, $prepend) { array_unshift($args, $prepend); return call_user_func_array($function, $args); }
+    public function query() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'assoc'); }
+    public function queryAllLists() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'list'); }
+    public function queryFullColumns() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'full'); }
 
-  public function queryRaw() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'raw_buf'); }
-  public function queryRawUnbuf() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'raw_unbuf'); }
+    public function queryRaw() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'raw_buf'); }
+    public function queryRawUnbuf() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'raw_unbuf'); }
 
-  protected function queryHelper() {
+    protected function queryHelper() {
     $args = func_get_args();
     $type = array_shift($args);
     $db = $this->get();
@@ -584,23 +584,23 @@ 
     $full_names = false;
 
     switch ($type) {
-      case 'assoc':
+        case 'assoc':
         break;
-      case 'list':
+        case 'list':
         $row_type = 'list';
         break;
-      case 'full':
+        case 'full':
         $row_type = 'list';
         $full_names = true;
         break;
-      case 'raw_buf':
+        case 'raw_buf':
         $row_type = 'raw';
         break;
-      case 'raw_unbuf':
+        case 'raw_unbuf':
         $is_buffered = false;
         $row_type = 'raw';
         break;
-      default:
+        default:
         $this->nonSQLError('Error -- invalid argument to queryHelper!');
     }
 
@@ -613,41 +613,41 @@ 
 
     // ----- BEGIN ERROR HANDLING
     if (!$sql || $db->error) {
-      if ($this->error_handler) {
+        if ($this->error_handler) {
         $db_error = $db->error;
         $db_errno = $db->errno;
     $db->query(
-      "INSERT INTO ".$GLOBALS['pre']."log_system SET
+        "INSERT INTO ".$GLOBALS['pre']."log_system SET
       date=".time().",
       qui=".$_SESSION['user_id'].",
       label='Query: ".addslashes($sql)."<br />Error: ".addslashes($db_error)."<br />@ ".mysqli_real_escape_string($link, filter_var($_SERVER['REQUEST_URI'], FILTER_SANITIZE_STRING))."',
       type='error'",
-      MYSQLI_USE_RESULT
+        MYSQLI_USE_RESULT
     );
 
         $error_handler = is_callable($this->error_handler) ? $this->error_handler : 'meekrodb_error_handler';
 
         call_user_func($error_handler, array(
-          'type' => 'sql',
-          'query' => $sql,
-          'error' => $db_error,
-          'code' => $db_errno
+            'type' => 'sql',
+            'query' => $sql,
+            'error' => $db_error,
+            'code' => $db_errno
         ));
-      }
+        }
 
-      if ($this->throw_exception_on_error) {
+        if ($this->throw_exception_on_error) {
         $e = new MeekroDBException($db_error, $sql, $db_errno);
         throw $e;
-      }
+        }
     } else if ($this->success_handler) {
-      $runtime = sprintf('%f', $runtime * 1000);
-      $success_handler = is_callable($this->success_handler) ? $this->success_handler : 'meekrodb_debugmode_handler';
+        $runtime = sprintf('%f', $runtime * 1000);
+        $success_handler = is_callable($this->success_handler) ? $this->success_handler : 'meekrodb_debugmode_handler';
 
-      call_user_func($success_handler, array(
+        call_user_func($success_handler, array(
         'query' => $sql,
         'runtime' => $runtime,
         'affected' => $db->affected_rows
-      ));
+        ));
     }
 
     // ----- END ERROR HANDLING
@@ -664,45 +664,45 @@ 
     $return = array();
 
     if ($full_names) {
-      $infos = array();
-      foreach ($result->fetch_fields() as $info) {
+        $infos = array();
+        foreach ($result->fetch_fields() as $info) {
         if (strlen($info->table)) $infos[] = $info->table . '.' . $info->name;
         else $infos[] = $info->name;
-      }
+        }
     }
 
     while ($row = ($row_type == 'assoc' ? $result->fetch_assoc() : $result->fetch_row())) {
-      if ($full_names) $row = array_combine($infos, $row);
-      $return[] = $row;
+        if ($full_names) $row = array_combine($infos, $row);
+        $return[] = $row;
     }
 
     // free results
     $result->free();
     while ($db->more_results()) {
-      $db->next_result();
-      if ($result = $db->use_result()) $result->free();
+        $db->next_result();
+        if ($result = $db->use_result()) $result->free();
     }
 
     return $return;
-  }
+    }
 
-  public function queryOneRow() { $args = func_get_args(); return call_user_func_array(array($this, 'queryFirstRow'), $args); }
-  public function queryFirstRow() {
+    public function queryOneRow() { $args = func_get_args(); return call_user_func_array(array($this, 'queryFirstRow'), $args); }
+    public function queryFirstRow() {
     $args = func_get_args();
     $result = call_user_func_array(array($this, 'query'), $args);
     if (! $result) return null;
     return reset($result);
-  }
+    }
 
-  public function queryOneList() { $args = func_get_args(); return call_user_func_array(array($this, 'queryFirstList'), $args); }
-  public function queryFirstList() {
+    public function queryOneList() { $args = func_get_args(); return call_user_func_array(array($this, 'queryFirstList'), $args); }
+    public function queryFirstList() {
     $args = func_get_args();
     $result = call_user_func_array(array($this, 'queryAllLists'), $args);
     if (! $result) return null;
     return reset($result);
-  }
+    }
 
-  public function queryFirstColumn() {
+    public function queryFirstColumn() {
     $args = func_get_args();
     $results = call_user_func_array(array($this, 'queryAllLists'), $args);
     $ret = array();
@@ -710,13 +710,13 @@ 
     if (!count($results) || !count($results[0])) return $ret;
 
     foreach ($results as $row) {
-      $ret[] = $row[0];
+        $ret[] = $row[0];
     }
 
     return $ret;
-  }
+    }
 
-  public function queryOneColumn() {
+    public function queryOneColumn() {
     $args = func_get_args();
     $column = array_shift($args);
     $results = call_user_func_array(array($this, 'query'), $args);
@@ -724,103 +724,103 @@ 
 
     if (!count($results) || !count($results[0])) return $ret;
     if ($column === null) {
-      $keys = array_keys($results[0]);
-      $column = $keys[0];
+        $keys = array_keys($results[0]);
+        $column = $keys[0];
     }
 
     foreach ($results as $row) {
-      $ret[] = $row[$column];
+        $ret[] = $row[$column];
     }
 
     return $ret;
-  }
+    }
 
-  public function queryFirstField() {
+    public function queryFirstField() {
     $args = func_get_args();
     $row = call_user_func_array(array($this, 'queryFirstList'), $args);
     if ($row == null) return null;
     return $row[0];
-  }
+    }
 
-  public function queryOneField() {
+    public function queryOneField() {
     $args = func_get_args();
     $column = array_shift($args);
 
     $row = call_user_func_array(array($this, 'queryOneRow'), $args);
     if ($row == null) {
-      return null;
+        return null;
     } else if ($column === null) {
-      $keys = array_keys($row);
-      $column = $keys[0];
+        $keys = array_keys($row);
+        $column = $keys[0];
     }
 
     return $row[$column];
-  }
+    }
 }
 
 class WhereClause {
-  public $type = 'and'; //AND or OR
-  public $negate = false;
-  public $clauses = array();
+    public $type = 'and'; //AND or OR
+    public $negate = false;
+    public $clauses = array();
 
-  function __construct($type) {
+    function __construct($type) {
     $type = strtolower($type);
     if ($type !== 'or' && $type !== 'and') DB::nonSQLError('you must use either WhereClause(and) or WhereClause(or)');
     $this->type = $type;
-  }
+    }
 
-  function add() {
+    function add() {
     $args = func_get_args();
     $sql = array_shift($args);
 
     if ($sql instanceof WhereClause) {
-      $this->clauses[] = $sql;
+        $this->clauses[] = $sql;
     } else {
-      $this->clauses[] = array('sql' => $sql, 'args' => $args);
+        $this->clauses[] = array('sql' => $sql, 'args' => $args);
+    }
     }
-  }
 
-  function negateLast() {
+    function negateLast() {
     $i = count($this->clauses) - 1;
     if (!isset($this->clauses[$i])) return;
 
     if ($this->clauses[$i] instanceof WhereClause) {
-      $this->clauses[$i]->negate();
+        $this->clauses[$i]->negate();
     } else {
-      $this->clauses[$i]['sql'] = 'NOT (' . $this->clauses[$i]['sql'] . ')';
+        $this->clauses[$i]['sql'] = 'NOT (' . $this->clauses[$i]['sql'] . ')';
+    }
     }
-  }
 
-  function negate() {
+    function negate() {
     $this->negate = ! $this->negate;
-  }
+    }
 
-  function addClause($type) {
+    function addClause($type) {
     $r = new WhereClause($type);
     $this->add($r);
     return $r;
-  }
+    }
 
-  function count() {
+    function count() {
     return count($this->clauses);
-  }
+    }
 
-  function textAndArgs() {
+    function textAndArgs() {
     $sql = array();
     $args = array();
 
     if (count($this->clauses) == 0) return array('(1)', $args);
 
     foreach ($this->clauses as $clause) {
-      if ($clause instanceof WhereClause) {
+        if ($clause instanceof WhereClause) {
         list($clause_sql, $clause_args) = $clause->textAndArgs();
-      } else {
+        } else {
         $clause_sql = $clause['sql'];
         $clause_args = $clause['args'];
-      }
+        }
 
-      $sql[] = "($clause_sql)";
-      $args = array_merge($args, $clause_args);
+        $sql[] = "($clause_sql)";
+        $args = array_merge($args, $clause_args);
     }
 
     if ($this->type == 'and') $sql = implode(' AND ', $sql);
@@ -828,111 +828,111 @@ 
 
     if ($this->negate) $sql = '(NOT ' . $sql . ')';
     return array($sql, $args);
-  }
+    }
 
-  // backwards compatability
-  // we now return full WhereClause object here and evaluate it in preparseQueryParams
-  function text() { return $this; }
+    // backwards compatability
+    // we now return full WhereClause object here and evaluate it in preparseQueryParams
+    function text() { return $this; }
 }
 
 class DBTransaction {
-  private $committed = false;
+    private $committed = false;
 
-  function __construct() {
+    function __construct() {
     DB::startTransaction();
-  }
-  function __destruct() {
+    }
+    function __destruct() {
     if (! $this->committed) DB::rollback();
-  }
-  function commit() {
+    }
+    function commit() {
     DB::commit();
     $this->committed = true;
-  }
+    }
 
 
 }
 
 class MeekroDBException extends Exception {
-  protected $query = '';
+    protected $query = '';
 
-  function __construct($message='', $query='', $code = 0) {
+    function __construct($message='', $query='', $code = 0) {
     parent::__construct($message);
     $this->query = $query;
-  $this->code = $code;
-  }
+    $this->code = $code;
+    }
 
-  public function getQuery() { return $this->query; }
+    public function getQuery() { return $this->query; }
 }
 
 class DBHelper {
-  /*
+    /*
     verticalSlice
     1. For an array of assoc rays, return an array of values for a particular key
     2. if $keyfield is given, same as above but use that hash key as the key in new array
   */
 
-  public static function verticalSlice($array, $field, $keyfield = null) {
+    public static function verticalSlice($array, $field, $keyfield = null) {
     $array = (array) $array;
 
     $R = array();
     foreach ($array as $obj) {
-      if (! array_key_exists($field, $obj)) die("verticalSlice: array doesn't have requested field\n");
+        if (! array_key_exists($field, $obj)) die("verticalSlice: array doesn't have requested field\n");
 
-      if ($keyfield) {
+        if ($keyfield) {
         if (! array_key_exists($keyfield, $obj)) die("verticalSlice: array doesn't have requested field\n");
         $R[$obj[$keyfield]] = $obj[$field];
-      } else {
+        } else {
         $R[] = $obj[$field];
-      }
+        }
     }
     return $R;
-  }
+    }
 
-  /*
+    /*
     reIndex
     For an array of assoc rays, return a new array of assoc rays using a certain field for keys
   */
 
-  public static function reIndex() {
+    public static function reIndex() {
     $fields = func_get_args();
     $array = array_shift($fields);
     $array = (array) $array;
 
     $R = array();
     foreach ($array as $obj) {
-      $target =& $R;
+        $target =& $R;
 
-      foreach ($fields as $field) {
+        foreach ($fields as $field) {
         if (! array_key_exists($field, $obj)) die("reIndex: array doesn't have requested field\n");
 
         $nextkey = $obj[$field];
         $target =& $target[$nextkey];
-      }
-      $target = $obj;
+        }
+        $target = $obj;
     }
     return $R;
-  }
+    }
 }
 
 function meekrodb_error_handler($params) {
-  echo prepareExchangedData('[{"error" : "'.$params['error'].'"}]', "encode");
+    echo prepareExchangedData('[{"error" : "'.$params['error'].'"}]', "encode");
 
-  die;
+    die;
 }
 
 function meekrodb_debugmode_handler($params) {
-  echo "QUERY: " . $params['query'] . " [" . $params['runtime'] . " ms]";
-  if (php_sapi_name() == 'cli' && empty($_SERVER['REMOTE_ADDR'])) {
+    echo "QUERY: " . $params['query'] . " [" . $params['runtime'] . " ms]";
+    if (php_sapi_name() == 'cli' && empty($_SERVER['REMOTE_ADDR'])) {
     echo "\n";
-  } else {
+    } else {
     echo "<br>\n";
-  }
+    }
 }
 
 class MeekroDBEval {
-  public $text = '';
+    public $text = '';
 
-  function __construct($text) {
+    function __construct($text) {
     $this->text = $text;
-  }
+    }
 }
\ No newline at end of file

includes/libraries/phpcrypt/Core.php

Indentation +585 added lines, -585 removed lines

@@ -33,590 +33,590 @@
  */
 class Core
 {
-	/** @type integer HASH_LEN The length of md5() hash string */
-	const HASH_LEN = 16;
-
-
-	/**
-	 * Constructor
-	 *
-	 */
-	protected function __construct()
-	{
-
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 */
-	protected function __destruct()
-	{
-
-	}
-
-
-	/**
-	 * Convert hexidecimal to a binary string (ex: "00110110")
-	 *
-	 * @param string $hex A string containing a hexidecimal number
-	 * @return string A string representation of a binary
-	 */
-	public static function hex2Bin($hex)
-	{
-		// if we do not have an even number of hex characters
-		// append a 0 to the beginning to make it even
-		if(strlen($hex) % 2)
-			$hex = "0$hex";
-
-		$parts = str_split($hex, 2);
-		$parts = array_map(function($v) {
-				$v = base_convert($v, 16, 2);
-				return str_pad($v, 8, "0", STR_PAD_LEFT);
-		}, $parts);
-
-		return implode("", $parts);
-	}
-
-
-	/**
-	 * Convert hex to a string
-	 *
-	 * @param string $hex A string representation of Hex (IE: "1a2b3c" not 0x1a2b3c)
-	 * @return string a string
-	 */
-	public static function hex2Str($hex)
-	{
-		// php version >= 5.4 have a hex2bin function, use it
-		// if it exists
-		if(function_exists("hex2bin"))
-			return hex2bin($hex);
-
-		$parts = str_split($hex, 2);
-		$parts = array_map(function($v) {
-				return chr(Core::hex2Dec($v));
-		}, $parts);
-
-		return implode("", $parts);
-	}
-
-
-	/**
-	 * Converts Hex to Decimal
-	 * This function just calls php's hexdec() function,  but I
-	 * encapsulated it in this function to keep things uniform
-	 * and have all possible conversion function available in
-	 * the Cipher class
-	 *
-	 * @param string $hex A hex number to convert to decimal
-	 * @return integer A decimal number
-	 */
-	public static function hex2Dec($hex)
-	{
-		return hexdec($hex);
-	}
-
-
-	/**
-	 * Convert binary string (ie 00110110) to hex
-	 *
-	 * @param string $bin A binary string
-	 * @return string A string representation of hexidecimal number
-	 */
-	public static function bin2Hex($bin)
-	{
-		$parts = str_split($bin, 8);
-
-		$parts = array_map(function($v) {
-			$v = str_pad($v, 8, "0", STR_PAD_LEFT);
-			$v = dechex(bindec($v));
-			return str_pad($v, 2, "0", STR_PAD_LEFT);
-		}, $parts);
-
-		return implode("", $parts);
-	}
-
-
-	/**
-	 * Converts a binary representation (ie 01101011)  back to a string
-	 *
-	 * @param string $bin a binary representation string
-	 * @return string A string of characters representing the binary
-	 */
-	public static function bin2Str($bin)
-	{
-		$hex = self::bin2Hex($bin);
-		return self::hex2Str($hex);
-	}
-
-
-	/**
-	 * Convert a binary string (ie: 01101011) to a decimal number
-	 *
-	 * @param string A string representation of a binary number
-	 * @return integer The number converted from the binary string
-	 */
-	public static function bin2Dec($bin)
-	{
-		return bindec($bin);
-	}
-
-
-	/**
-	 * Convert a string to hex
-	 * This function calls the PHP bin2hex(), and is here
-	 * for consistency with the other string functions
-	 *
-	 * @param string $str A string
-	 * @return string A string representation of hexidecimal number
-	 */
-	public static function str2Hex($str)
-	{
-		return bin2hex($str);
-	}
-
-
-	/**
-	 * Convert a string of characters to a decimal number
-	 *
-	 * @param string $str The string to convert to decimal
-	 * @return integer The integer converted from the string
-	 */
-	public static function str2Dec($str)
-	{
-		$hex = self::str2Hex($str);
-		return self::hex2Dec($hex);
-	}
-
-
-	/**
-	 * Converts a string to binary representation (ie 01101011)
-	 *
-	 * @param string $str A string
-	 * @return string A binary representation of the the string
-	 */
-	public static function str2Bin($str)
-	{
-		$hex = self::str2Hex($str);
-		$parts = str_split($hex, 2);
-
-		$parts = array_map(function($v) {
-			return Core::hex2Bin($v);
-		}, $parts);
-
-		return implode("", $parts);
-	}
-
-
-	/**
-	 * Converts Decimal to Hex
-	 * This function just calls php's dechex() function,  but I
-	 * encapsulated it in this function to keep things uniform
-	 * and have all possible conversion function available in
-	 * the Cipher class
-	 *
-	 * The parameter $req_bytes will pad the return hex with NULL (00)
-	 * until the hex represents the number of bytes given to $req_bytes
-	 * This is because dechex() drops null bytes from the Hex, which may
-	 * be needed in some cases
-	 *
-	 * @param integer $dec A decimal number to convert
-	 * @param integer $req_bytes Optional, forces the string to be at least
-	 *	$req_bytes in size, this is needed because on occasion left most null bytes
-	 *	are dropped in dechex(), causing the string to have a shorter byte
-	 *	size than the initial integer.
-	 * @return string A hexidecimal representation of the decimal number
-	 */
-	public static function dec2Hex($dec, $req_bytes = 0)
-	{
-		$hex = dechex($dec);
-
-		// if we do not have an even number of hex characters
-		// append a 0 to the beginning. dechex() drops leading 0's
-		if(strlen($hex) % 2)
-			$hex = "0$hex";
-
-		// if the number of bytes in the hex is less than
-		// what we need it to be, add null bytes to the
-		// front of the hex to padd it to the required size
-		if(($req_bytes * 2) > strlen($hex))
-			$hex = str_pad($hex, ($req_bytes * 2), "0", STR_PAD_LEFT);
-
-		return $hex;
-	}
-
-
-	/**
-	 * Converts Decimal to Binary
-	 * This function just calls php's decbin() function,  but I
-	 * encapsulated it in this function to keep things uniform
-	 * and have all possible conversion function available in
-	 * the Cipher class
-	 *
-	 * @param integer $dec A decimal number to convert
-	 * @param integer $req_bytes Optional, forces the string to be at least
-	 *	$req_bytes in size, this is needed because on occasion left most null bytes
-	 *	are dropped in dechex(), causing the string to have a shorter byte
-	 *	size than the initial integer.
-	 * @return string A binary representation of the decimal number
-	 */
-	public static function dec2Bin($dec, $req_bytes = 0)
-	{
-		$hex = self::dec2Hex($dec, $req_bytes);
-		return self::hex2Bin($hex);
-	}
-
-
-	/**
-	 * Convert a decimal to a string of bytes
-	 *
-	 * @param integer $dec A decimal number
-	 * @param integer $req_bytes Optional, forces the string to be at least
-	 *	$req_bytes in size, this is needed because on occasion left most null bytes
-	 *	are dropped in dechex(), causing the string to have a shorter byte
-	 *	size than the initial integer.
-	 * @return string A string with the number of bytes equal to $dec
-	 */
-	public static function dec2Str($dec, $req_bytes = 0)
-	{
-		$hex = self::dec2Hex($dec, $req_bytes);
-		return self::hex2Str($hex);
-	}
-
-
-	/**
-	 * XORs two binary strings (representation of binary, ie 01101011),
-	 * assumed to be equal length
-	 *
-	 * @param string $a A string that represents binary
-	 * @param string $b A string that represents binary
-	 * @return string A representation of binary
-	 */
-	public static function xorBin($a, $b)
-	{
-		$len_a = strlen($a);
-		$len_b = strlen($b);
-		$width = $len_a;
-
-		// first determine if the two binary strings are the same length,
-		// and if not get them to the same length
-		if($len_a > $len_b)
-		{
-			$width = $len_a;
-			$b = str_pad($b, $width, "0", STR_PAD_LEFT);
-		}
-		else if($len_a < $len_b)
-		{
-			$width = $len_b;
-			$a = str_pad($a, $width, "0", STR_PAD_LEFT);
-		}
-
-		// fortunately PHP knows how to XOR each byte in a string
-		// so we don't have to loop to do it
-		$bin = self::bin2Str($a) ^ self::bin2Str($b);
-		return self::str2Bin($bin);
-	}
-
-
-	/**
-	 * ExclusiveOR hex values. Supports an unlimited number of parameters.
-	 * The values are string representations of hex values
-	 * IE: "0a1b2c3d" not 0x0a1b2c3d
-	 *
-	 * @param string Unlimited number parameters, each a string representation of hex
-	 * @return string A string representation of the result in Hex
-	 */
-	public static function xorHex()
-	{
-		$hex   = func_get_args();
-		$count = func_num_args();
-
-		// we need a minimum of 2 values
-		if($count < 2)
-			return false;
-
-		// first get all hex values to an even number
-		array_walk($hex, function(&$val, $i){
-			if(strlen($val) % 2)
-				$val = "0".$val;
-		});
-
-		$res = 0;
-		for($i = 0; $i < $count; ++$i)
-		{
-			// if this is the first loop, set the 'result' to the first
-			// hex value
-			if($i == 0)
-				$res = $hex[0];
-			else
-			{
-				// to make the code easier to follow
-				$h1 = $res;
-				$h2 = $hex[$i];
-
-				// get lengths
-				$len1 = strlen($h1);
-				$len2 = strlen($h2);
-
-				// now check that both hex values are the same length,
-				// if not pad them with 0's until they are
-				if($len1 > $len2)
-					$h2 = str_pad($h2, $len1, "0", STR_PAD_LEFT);
-				else if($len1 < $len2)
-					$h1 = str_pad($h1, $len2, "0", STR_PAD_LEFT);
-
-				// PHP knows how to XOR each byte in a string, so convert the
-				// hex to a string, XOR, and convert back
-				$res = self::hex2Str($h1) ^ self::hex2Str($h2);
-				$res = self::str2Hex($res);
-			}
-		}
-
-		return $res;
-	}
-
-
-	/**
-	 * Forces an integer to be signed
-	 *
-	 * @param integer $int An integer
-	 * @return integer An signed integer
-	 */
-	public static function sInt($int)
-	{
-		$arr = unpack("i", pack("i", $int));
-		return $arr[1];
-	}
-
-
-	/**
-	 * Forces an integer to be unsigned
-	 *
-	 * @param integer $int A signed integer
-	 * @return integer An unsigned integer
-	 */
-	public static function uInt($int)
-	{
-		$arr = unpack("I", pack("I", $int));
-		$ret = $arr[1];
-
-		// On 32 bit platforms unpack() and pack() do not convert
-		// from signed to unsigned properly all the time, it will return
-		// the same negative number given to it, the work around is
-		// to use sprintf().
-		// Tested with php 5.3.x on Windows XP & Linux 32bit
-		if($ret < 0)
-			$ret = sprintf("%u", $ret) + 0; // convert from string to int
-
-		return $ret;
-	}
-
-
-	/**
-	 * Forces an integer to be a 32 bit signed integer
-	 *
-	 * @param integer $int An integer
-	 * @return integer An signed 32 bit integer
-	 */
-	public static function sInt32($int)
-	{
-		if(PHP_INT_SIZE === 4) // 32 bit
-			return self::sInt($int);
-		else // PHP_INT_SIZE === 8 // 64 bit
-		{
-			$arr = unpack("l", pack("l", $int));
-			return $arr[1];
-		}
-	}
-
-
-	/**
-	 * Force an integer to be a 32 bit unsigned integer
-	 *
-	 * @param integer $int An integer
-	 * @return integer An unsigned 32 bit integer
-	 */
-	public static function uInt32($int)
-	{
-		if(PHP_INT_SIZE === 4) // 32 bit
-			return self::uInt($int);
-		else // PHP_INT_SIZE === 8  // 64 bit
-		{
-			$arr = unpack("L", pack("L", $int));
-			return $arr[1];
-		}
-	}
-
-
-	/**
-	 * Converts an integer to the value for an signed char
-	 *
-	 * @param integer $int The integer to convert to a signed char
-	 * @return integer A signed integer, representing a signed char
-	 */
-	public static function sChar($int)
-	{
-		$arr = unpack("c", pack("c", $int));
-		return $arr[1];
-	}
-
-
-	/**
-	 * Converts an integer to the value for an unsigned char
-	 *
-	 * @param integer $int The integer to convert to a unsigned char
-	 * @return integer An unsigned integer, representing a unsigned char
-	 */
-	public static function uChar($int)
-	{
-		$arr = unpack("C", pack("C", $int));
-		return $arr[1];
-	}
-
-
-	/**
-	 * Rotates bits Left, appending the bits pushed off the left onto the right
-	 *
-	 * @param integer $n The integer to rotate bits to the left
-	 * @param integer $shifts The number of shifts left to make
-	 * @return integer The resulting value from the rotation
-	 */
-	public static function rotBitsLeft32($i, $shifts)
-	{
-		if($shifts <= 0)
-			return $i;
-
-		$shifts &= 0x1f; /* higher rotates would not bring anything */
-
-		// this is causing problems on 32 bit platform
-		//return self::uInt32(($i << $shifts) | ($i >> (32 - $shifts)));
-
-		// so lets cheat: convert to binary string, rotate left, and
-		// convert back to decimal
-		$i = self::dec2Bin(self::uInt32($i), 4);
-		$i = substr($i, $shifts).substr($i, 0, $shifts);
-		return self::bin2Dec($i);
-
-	}
-
-
-	/**
-	 * Rotates bits right, appending the bits pushed off the right onto the left
-	 *
-	 * @param integer $n The integer to rotate bits to the right
-	 * @param integer $shifts The number of shifts right to make
-	 * @return integer The resulting value from the rotation
-	 */
-	public static function rotBitsRight32($i, $shifts)
-	{
-		if($shifts <= 0)
-			return $i;
-
-		$shifts &= 0x1f; /* higher rotates would not bring anything */
-
-		// this might cause problems on 32 bit platforms since rotBitsLeft32 was
-		// having a problem with some bit shifts on 32 bits
-		// return self::uInt32(($i >> $shifts) | ($i << (32 - $shifts)));
-
-		// so lets cheat: convert to binary string, rotate right,
-		// and convert back to decimal
-		$i = self::dec2Bin($i, 4);
-		$i = substr($i, (-1 * $shifts)).substr($i, 0, (-1 * $shifts));
-		return self::bin2Dec($i);
-	}
-
-
-	/**
-	 * Create a string of random bytes, used for creating an IV
-	 * and a random key. See PHP_Crypt::createKey() and PHP_Crypt::createIV()
-	 * There are 4 ways to auto generate random bytes by setting $src parameter
-	 * PHP_Crypt::RAND - Default, uses mt_rand()
-	 * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
-	 * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
-	 * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
-	 *
-	 * @param string $src Optional, Use the $src to create the random bytes
-	 * 	by default PHP_Crypt::RAND is used when $src is not specified
-	 * @param integer $byte_len The length of the byte string to create
-	 * @return string A random string of bytes
-	 */
-	public static function randBytes($src = PHP_Crypt::RAND, $byte_len = PHP_Crypt::RAND_DEFAULT_SZ)
-	{
-		$bytes = "";
-		$err_msg = "";
-
-		if($src == PHP_Crypt::RAND_DEV_RAND)
-		{
-			if(file_exists(PHP_Crypt::RAND_DEV_RAND))
-				$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_RAND, false, null, 0, $byte_len);
-			else
-				$err_msg = PHP_Crypt::RAND_DEV_RAND." not found";
-		}
-		else if($src == PHP_Crypt::RAND_DEV_URAND)
-		{
-			if(file_exists(PHP_Crypt::RAND_DEV_URAND))
-				$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_URAND, false, null, 0, $byte_len);
-			else
-				$err_msg = PHP_Crypt::RAND_DEV_URAND." not found";
-		}
-		else if($src == PHP_Crypt::RAND_WIN_COM)
-		{
-			if(extension_loaded('com_dotnet'))
-			{
-				// http://msdn.microsoft.com/en-us/library/aa388176(VS.85).aspx
-				try
-				{
-					// request a random number in $byte_len bytes, returned
-					// as base_64 encoded string. This is because PHP munges the
-					// binary data on Windows
-					$com = @new \COM("CAPICOM.Utilities.1");
-					$bytes = $com->GetRandom($byte_len, 0);
-				}
-				catch(Exception $e)
-				{
-					$err_msg  = "Windows COM exception: ".$e->getMessage();
-				}
-
-				if(!$bytes)
-					$err_msg  = "Windows COM failed to create random string of bytes";
-			}
-			else
-				$err_msg = "The COM_DOTNET extension is not loaded";
-		}
-
-		// trigger a warning if something went wrong
-		if($err_msg != "")
-			trigger_error("$err_msg. Defaulting to PHP_Crypt::RAND", E_USER_WARNING);
-
-		// if the random bytes where not created properly or PHP_Crypt::RAND was
-		// passed as the $src param, create the bytes using mt_rand(). It's not
-		// the most secure option but we have no other choice
-		if(strlen($bytes) < $byte_len)
-		{
-			$bytes = "";
-
-			// md5() hash a random number to get a 16 byte string, keep looping
-			// until we have a string as long or longer than the ciphers block size
-			for($i = 0; ($i * self::HASH_LEN) < $byte_len; ++$i)
-				$bytes .= md5(mt_rand(), true);
-		}
-
-		// because $bytes may have come from mt_rand() or /dev/urandom which are not
-		// cryptographically secure, lets add another layer of 'randomness' before
-		// the final md5() below
-		$bytes = str_shuffle($bytes);
-
-		// md5() the $bytes to add extra randomness. Since md5() only returns
-		// 16 bytes, we may need to loop to generate a string of $bytes big enough for
-		// some ciphers which have a block size larger than 16 bytes
-		$tmp = "";
-		$loop = ceil(strlen($bytes) / self::HASH_LEN);
-		for($i = 0; $i < $loop; ++$i)
-			$tmp .= md5(substr($bytes, ($i * self::HASH_LEN), self::HASH_LEN), true);
-
-		// grab the number of bytes equal to the requested $byte_len
-		return substr($tmp, 0, $byte_len);
-	}
+    /** @type integer HASH_LEN The length of md5() hash string */
+    const HASH_LEN = 16;
+
+
+    /**
+     * Constructor
+     *
+     */
+    protected function __construct()
+    {
+
+    }
+
+
+    /**
+     * Destructor
+     *
+     */
+    protected function __destruct()
+    {
+
+    }
+
+
+    /**
+     * Convert hexidecimal to a binary string (ex: "00110110")
+     *
+     * @param string $hex A string containing a hexidecimal number
+     * @return string A string representation of a binary
+     */
+    public static function hex2Bin($hex)
+    {
+        // if we do not have an even number of hex characters
+        // append a 0 to the beginning to make it even
+        if(strlen($hex) % 2)
+            $hex = "0$hex";
+
+        $parts = str_split($hex, 2);
+        $parts = array_map(function($v) {
+                $v = base_convert($v, 16, 2);
+                return str_pad($v, 8, "0", STR_PAD_LEFT);
+        }, $parts);
+
+        return implode("", $parts);
+    }
+
+
+    /**
+     * Convert hex to a string
+     *
+     * @param string $hex A string representation of Hex (IE: "1a2b3c" not 0x1a2b3c)
+     * @return string a string
+     */
+    public static function hex2Str($hex)
+    {
+        // php version >= 5.4 have a hex2bin function, use it
+        // if it exists
+        if(function_exists("hex2bin"))
+            return hex2bin($hex);
+
+        $parts = str_split($hex, 2);
+        $parts = array_map(function($v) {
+                return chr(Core::hex2Dec($v));
+        }, $parts);
+
+        return implode("", $parts);
+    }
+
+
+    /**
+     * Converts Hex to Decimal
+     * This function just calls php's hexdec() function,  but I
+     * encapsulated it in this function to keep things uniform
+     * and have all possible conversion function available in
+     * the Cipher class
+     *
+     * @param string $hex A hex number to convert to decimal
+     * @return integer A decimal number
+     */
+    public static function hex2Dec($hex)
+    {
+        return hexdec($hex);
+    }
+
+
+    /**
+     * Convert binary string (ie 00110110) to hex
+     *
+     * @param string $bin A binary string
+     * @return string A string representation of hexidecimal number
+     */
+    public static function bin2Hex($bin)
+    {
+        $parts = str_split($bin, 8);
+
+        $parts = array_map(function($v) {
+            $v = str_pad($v, 8, "0", STR_PAD_LEFT);
+            $v = dechex(bindec($v));
+            return str_pad($v, 2, "0", STR_PAD_LEFT);
+        }, $parts);
+
+        return implode("", $parts);
+    }
+
+
+    /**
+     * Converts a binary representation (ie 01101011)  back to a string
+     *
+     * @param string $bin a binary representation string
+     * @return string A string of characters representing the binary
+     */
+    public static function bin2Str($bin)
+    {
+        $hex = self::bin2Hex($bin);
+        return self::hex2Str($hex);
+    }
+
+
+    /**
+     * Convert a binary string (ie: 01101011) to a decimal number
+     *
+     * @param string A string representation of a binary number
+     * @return integer The number converted from the binary string
+     */
+    public static function bin2Dec($bin)
+    {
+        return bindec($bin);
+    }
+
+
+    /**
+     * Convert a string to hex
+     * This function calls the PHP bin2hex(), and is here
+     * for consistency with the other string functions
+     *
+     * @param string $str A string
+     * @return string A string representation of hexidecimal number
+     */
+    public static function str2Hex($str)
+    {
+        return bin2hex($str);
+    }
+
+
+    /**
+     * Convert a string of characters to a decimal number
+     *
+     * @param string $str The string to convert to decimal
+     * @return integer The integer converted from the string
+     */
+    public static function str2Dec($str)
+    {
+        $hex = self::str2Hex($str);
+        return self::hex2Dec($hex);
+    }
+
+
+    /**
+     * Converts a string to binary representation (ie 01101011)
+     *
+     * @param string $str A string
+     * @return string A binary representation of the the string
+     */
+    public static function str2Bin($str)
+    {
+        $hex = self::str2Hex($str);
+        $parts = str_split($hex, 2);
+
+        $parts = array_map(function($v) {
+            return Core::hex2Bin($v);
+        }, $parts);
+
+        return implode("", $parts);
+    }
+
+
+    /**
+     * Converts Decimal to Hex
+     * This function just calls php's dechex() function,  but I
+     * encapsulated it in this function to keep things uniform
+     * and have all possible conversion function available in
+     * the Cipher class
+     *
+     * The parameter $req_bytes will pad the return hex with NULL (00)
+     * until the hex represents the number of bytes given to $req_bytes
+     * This is because dechex() drops null bytes from the Hex, which may
+     * be needed in some cases
+     *
+     * @param integer $dec A decimal number to convert
+     * @param integer $req_bytes Optional, forces the string to be at least
+     *	$req_bytes in size, this is needed because on occasion left most null bytes
+     *	are dropped in dechex(), causing the string to have a shorter byte
+     *	size than the initial integer.
+     * @return string A hexidecimal representation of the decimal number
+     */
+    public static function dec2Hex($dec, $req_bytes = 0)
+    {
+        $hex = dechex($dec);
+
+        // if we do not have an even number of hex characters
+        // append a 0 to the beginning. dechex() drops leading 0's
+        if(strlen($hex) % 2)
+            $hex = "0$hex";
+
+        // if the number of bytes in the hex is less than
+        // what we need it to be, add null bytes to the
+        // front of the hex to padd it to the required size
+        if(($req_bytes * 2) > strlen($hex))
+            $hex = str_pad($hex, ($req_bytes * 2), "0", STR_PAD_LEFT);
+
+        return $hex;
+    }
+
+
+    /**
+     * Converts Decimal to Binary
+     * This function just calls php's decbin() function,  but I
+     * encapsulated it in this function to keep things uniform
+     * and have all possible conversion function available in
+     * the Cipher class
+     *
+     * @param integer $dec A decimal number to convert
+     * @param integer $req_bytes Optional, forces the string to be at least
+     *	$req_bytes in size, this is needed because on occasion left most null bytes
+     *	are dropped in dechex(), causing the string to have a shorter byte
+     *	size than the initial integer.
+     * @return string A binary representation of the decimal number
+     */
+    public static function dec2Bin($dec, $req_bytes = 0)
+    {
+        $hex = self::dec2Hex($dec, $req_bytes);
+        return self::hex2Bin($hex);
+    }
+
+
+    /**
+     * Convert a decimal to a string of bytes
+     *
+     * @param integer $dec A decimal number
+     * @param integer $req_bytes Optional, forces the string to be at least
+     *	$req_bytes in size, this is needed because on occasion left most null bytes
+     *	are dropped in dechex(), causing the string to have a shorter byte
+     *	size than the initial integer.
+     * @return string A string with the number of bytes equal to $dec
+     */
+    public static function dec2Str($dec, $req_bytes = 0)
+    {
+        $hex = self::dec2Hex($dec, $req_bytes);
+        return self::hex2Str($hex);
+    }
+
+
+    /**
+     * XORs two binary strings (representation of binary, ie 01101011),
+     * assumed to be equal length
+     *
+     * @param string $a A string that represents binary
+     * @param string $b A string that represents binary
+     * @return string A representation of binary
+     */
+    public static function xorBin($a, $b)
+    {
+        $len_a = strlen($a);
+        $len_b = strlen($b);
+        $width = $len_a;
+
+        // first determine if the two binary strings are the same length,
+        // and if not get them to the same length
+        if($len_a > $len_b)
+        {
+            $width = $len_a;
+            $b = str_pad($b, $width, "0", STR_PAD_LEFT);
+        }
+        else if($len_a < $len_b)
+        {
+            $width = $len_b;
+            $a = str_pad($a, $width, "0", STR_PAD_LEFT);
+        }
+
+        // fortunately PHP knows how to XOR each byte in a string
+        // so we don't have to loop to do it
+        $bin = self::bin2Str($a) ^ self::bin2Str($b);
+        return self::str2Bin($bin);
+    }
+
+
+    /**
+     * ExclusiveOR hex values. Supports an unlimited number of parameters.
+     * The values are string representations of hex values
+     * IE: "0a1b2c3d" not 0x0a1b2c3d
+     *
+     * @param string Unlimited number parameters, each a string representation of hex
+     * @return string A string representation of the result in Hex
+     */
+    public static function xorHex()
+    {
+        $hex   = func_get_args();
+        $count = func_num_args();
+
+        // we need a minimum of 2 values
+        if($count < 2)
+            return false;
+
+        // first get all hex values to an even number
+        array_walk($hex, function(&$val, $i){
+            if(strlen($val) % 2)
+                $val = "0".$val;
+        });
+
+        $res = 0;
+        for($i = 0; $i < $count; ++$i)
+        {
+            // if this is the first loop, set the 'result' to the first
+            // hex value
+            if($i == 0)
+                $res = $hex[0];
+            else
+            {
+                // to make the code easier to follow
+                $h1 = $res;
+                $h2 = $hex[$i];
+
+                // get lengths
+                $len1 = strlen($h1);
+                $len2 = strlen($h2);
+
+                // now check that both hex values are the same length,
+                // if not pad them with 0's until they are
+                if($len1 > $len2)
+                    $h2 = str_pad($h2, $len1, "0", STR_PAD_LEFT);
+                else if($len1 < $len2)
+                    $h1 = str_pad($h1, $len2, "0", STR_PAD_LEFT);
+
+                // PHP knows how to XOR each byte in a string, so convert the
+                // hex to a string, XOR, and convert back
+                $res = self::hex2Str($h1) ^ self::hex2Str($h2);
+                $res = self::str2Hex($res);
+            }
+        }
+
+        return $res;
+    }
+
+
+    /**
+     * Forces an integer to be signed
+     *
+     * @param integer $int An integer
+     * @return integer An signed integer
+     */
+    public static function sInt($int)
+    {
+        $arr = unpack("i", pack("i", $int));
+        return $arr[1];
+    }
+
+
+    /**
+     * Forces an integer to be unsigned
+     *
+     * @param integer $int A signed integer
+     * @return integer An unsigned integer
+     */
+    public static function uInt($int)
+    {
+        $arr = unpack("I", pack("I", $int));
+        $ret = $arr[1];
+
+        // On 32 bit platforms unpack() and pack() do not convert
+        // from signed to unsigned properly all the time, it will return
+        // the same negative number given to it, the work around is
+        // to use sprintf().
+        // Tested with php 5.3.x on Windows XP & Linux 32bit
+        if($ret < 0)
+            $ret = sprintf("%u", $ret) + 0; // convert from string to int
+
+        return $ret;
+    }
+
+
+    /**
+     * Forces an integer to be a 32 bit signed integer
+     *
+     * @param integer $int An integer
+     * @return integer An signed 32 bit integer
+     */
+    public static function sInt32($int)
+    {
+        if(PHP_INT_SIZE === 4) // 32 bit
+            return self::sInt($int);
+        else // PHP_INT_SIZE === 8 // 64 bit
+        {
+            $arr = unpack("l", pack("l", $int));
+            return $arr[1];
+        }
+    }
+
+
+    /**
+     * Force an integer to be a 32 bit unsigned integer
+     *
+     * @param integer $int An integer
+     * @return integer An unsigned 32 bit integer
+     */
+    public static function uInt32($int)
+    {
+        if(PHP_INT_SIZE === 4) // 32 bit
+            return self::uInt($int);
+        else // PHP_INT_SIZE === 8  // 64 bit
+        {
+            $arr = unpack("L", pack("L", $int));
+            return $arr[1];
+        }
+    }
+
+
+    /**
+     * Converts an integer to the value for an signed char
+     *
+     * @param integer $int The integer to convert to a signed char
+     * @return integer A signed integer, representing a signed char
+     */
+    public static function sChar($int)
+    {
+        $arr = unpack("c", pack("c", $int));
+        return $arr[1];
+    }
+
+
+    /**
+     * Converts an integer to the value for an unsigned char
+     *
+     * @param integer $int The integer to convert to a unsigned char
+     * @return integer An unsigned integer, representing a unsigned char
+     */
+    public static function uChar($int)
+    {
+        $arr = unpack("C", pack("C", $int));
+        return $arr[1];
+    }
+
+
+    /**
+     * Rotates bits Left, appending the bits pushed off the left onto the right
+     *
+     * @param integer $n The integer to rotate bits to the left
+     * @param integer $shifts The number of shifts left to make
+     * @return integer The resulting value from the rotation
+     */
+    public static function rotBitsLeft32($i, $shifts)
+    {
+        if($shifts <= 0)
+            return $i;
+
+        $shifts &= 0x1f; /* higher rotates would not bring anything */
+
+        // this is causing problems on 32 bit platform
+        //return self::uInt32(($i << $shifts) | ($i >> (32 - $shifts)));
+
+        // so lets cheat: convert to binary string, rotate left, and
+        // convert back to decimal
+        $i = self::dec2Bin(self::uInt32($i), 4);
+        $i = substr($i, $shifts).substr($i, 0, $shifts);
+        return self::bin2Dec($i);
+
+    }
+
+
+    /**
+     * Rotates bits right, appending the bits pushed off the right onto the left
+     *
+     * @param integer $n The integer to rotate bits to the right
+     * @param integer $shifts The number of shifts right to make
+     * @return integer The resulting value from the rotation
+     */
+    public static function rotBitsRight32($i, $shifts)
+    {
+        if($shifts <= 0)
+            return $i;
+
+        $shifts &= 0x1f; /* higher rotates would not bring anything */
+
+        // this might cause problems on 32 bit platforms since rotBitsLeft32 was
+        // having a problem with some bit shifts on 32 bits
+        // return self::uInt32(($i >> $shifts) | ($i << (32 - $shifts)));
+
+        // so lets cheat: convert to binary string, rotate right,
+        // and convert back to decimal
+        $i = self::dec2Bin($i, 4);
+        $i = substr($i, (-1 * $shifts)).substr($i, 0, (-1 * $shifts));
+        return self::bin2Dec($i);
+    }
+
+
+    /**
+     * Create a string of random bytes, used for creating an IV
+     * and a random key. See PHP_Crypt::createKey() and PHP_Crypt::createIV()
+     * There are 4 ways to auto generate random bytes by setting $src parameter
+     * PHP_Crypt::RAND - Default, uses mt_rand()
+     * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
+     * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
+     * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
+     *
+     * @param string $src Optional, Use the $src to create the random bytes
+     * 	by default PHP_Crypt::RAND is used when $src is not specified
+     * @param integer $byte_len The length of the byte string to create
+     * @return string A random string of bytes
+     */
+    public static function randBytes($src = PHP_Crypt::RAND, $byte_len = PHP_Crypt::RAND_DEFAULT_SZ)
+    {
+        $bytes = "";
+        $err_msg = "";
+
+        if($src == PHP_Crypt::RAND_DEV_RAND)
+        {
+            if(file_exists(PHP_Crypt::RAND_DEV_RAND))
+                $bytes = file_get_contents(PHP_CRYPT::RAND_DEV_RAND, false, null, 0, $byte_len);
+            else
+                $err_msg = PHP_Crypt::RAND_DEV_RAND." not found";
+        }
+        else if($src == PHP_Crypt::RAND_DEV_URAND)
+        {
+            if(file_exists(PHP_Crypt::RAND_DEV_URAND))
+                $bytes = file_get_contents(PHP_CRYPT::RAND_DEV_URAND, false, null, 0, $byte_len);
+            else
+                $err_msg = PHP_Crypt::RAND_DEV_URAND." not found";
+        }
+        else if($src == PHP_Crypt::RAND_WIN_COM)
+        {
+            if(extension_loaded('com_dotnet'))
+            {
+                // http://msdn.microsoft.com/en-us/library/aa388176(VS.85).aspx
+                try
+                {
+                    // request a random number in $byte_len bytes, returned
+                    // as base_64 encoded string. This is because PHP munges the
+                    // binary data on Windows
+                    $com = @new \COM("CAPICOM.Utilities.1");
+                    $bytes = $com->GetRandom($byte_len, 0);
+                }
+                catch(Exception $e)
+                {
+                    $err_msg  = "Windows COM exception: ".$e->getMessage();
+                }
+
+                if(!$bytes)
+                    $err_msg  = "Windows COM failed to create random string of bytes";
+            }
+            else
+                $err_msg = "The COM_DOTNET extension is not loaded";
+        }
+
+        // trigger a warning if something went wrong
+        if($err_msg != "")
+            trigger_error("$err_msg. Defaulting to PHP_Crypt::RAND", E_USER_WARNING);
+
+        // if the random bytes where not created properly or PHP_Crypt::RAND was
+        // passed as the $src param, create the bytes using mt_rand(). It's not
+        // the most secure option but we have no other choice
+        if(strlen($bytes) < $byte_len)
+        {
+            $bytes = "";
+
+            // md5() hash a random number to get a 16 byte string, keep looping
+            // until we have a string as long or longer than the ciphers block size
+            for($i = 0; ($i * self::HASH_LEN) < $byte_len; ++$i)
+                $bytes .= md5(mt_rand(), true);
+        }
+
+        // because $bytes may have come from mt_rand() or /dev/urandom which are not
+        // cryptographically secure, lets add another layer of 'randomness' before
+        // the final md5() below
+        $bytes = str_shuffle($bytes);
+
+        // md5() the $bytes to add extra randomness. Since md5() only returns
+        // 16 bytes, we may need to loop to generate a string of $bytes big enough for
+        // some ciphers which have a block size larger than 16 bytes
+        $tmp = "";
+        $loop = ceil(strlen($bytes) / self::HASH_LEN);
+        for($i = 0; $i < $loop; ++$i)
+            $tmp .= md5(substr($bytes, ($i * self::HASH_LEN), self::HASH_LEN), true);
+
+        // grab the number of bytes equal to the requested $byte_len
+        return substr($tmp, 0, $byte_len);
+    }
 }
 ?>

includes/libraries/phpcrypt/phpCrypt.php

Indentation +393 added lines, -393 removed lines

@@ -35,423 +35,423 @@
  */
 class PHP_Crypt
 {
-	// Ciphers
-	const CIPHER_3DES			= "3DES";
-	const CIPHER_3WAY			= "3-Way";
-	const CIPHER_AES_128		= "AES-128";
-	const CIPHER_AES_192		= "AES-192";
-	const CIPHER_AES_256		= "AES-256";
-	const CIPHER_ARC4			= "ARC4"; // Alternative RC4
-	const CIPHER_BLOWFISH		= "Blowfish";
-	const CIPHER_CAST_128		= "CAST-128";
-	const CIPHER_CAST_256		= "CAST-256";
-	const CIPHER_DES			= "DES";
-	const CIPHER_ENIGMA			= "Enigma";
-	const CIPHER_GOST			= "GOST";
-	const CIPHER_RC2			= "RC2";
-	const CIPHER_RIJNDAEL_128	= "Rijndael-128";
-	const CIPHER_RIJNDAEL_192	= "Rijndael-192";
-	const CIPHER_RIJNDAEL_256	= "Rijndael-256";
-	const CIPHER_SKIPJACK		= "Skipjack";
-	const CIPHER_SIMPLEXOR		= "SimpleXOR";
-	const CIPHER_VIGENERE		= "Vigenere"; // historical
-
-	// Modes
-	const MODE_CBC	= "CBC";
-	const MODE_CFB	= "CFB";  // 8 bit cfb mode
-	const MODE_CTR	= "CTR";
-	const MODE_ECB	= "ECB";
-	const MODE_NCFB	= "NCFB"; // blocksize cfb mode
-	const MODE_NOFB	= "NOFB"; // blocksize ofb mode
-	const MODE_OFB	= "OFB";  // 8 bit ofb mode
-	const MODE_PCBC	= "PCBC";
-	const MODE_RAW	= "Raw";  // raw encryption, with no mode
-	const MODE_STREAM = "Stream"; // used only for stream ciphers
-
-	// The source of random data used to create keys and IV's
-	// Used for PHP_Crypt::createKey(), PHP_Crypt::createIV()
-	const RAND			= "rand"; // uses mt_rand(), windows & unix
-	const RAND_DEV_RAND	= "/dev/random"; // unix only
-	const RAND_DEV_URAND= "/dev/urandom";// unix only
-	const RAND_WIN_COM	= "wincom";		 // windows only, COM extension
-	const RAND_DEFAULT_SZ = 32;			 // the default number of bytes returned
-
-	// Padding types
-	const PAD_ZERO			= 0;
-	const PAD_ANSI_X923		= 1;
-	const PAD_ISO_10126		= 2;
-	const PAD_PKCS7			= 3;
-	const PAD_ISO_7816_4	= 4;
-
-
-	/** @type object $cipher An instance of the cipher object selected */
-	private $cipher = null;
-
-	/** @type object $mode An instance of the mode object selected */
-	private $mode = null;
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key to use for the selected Cipher
-	 * @param string $cipher The type of cipher to use
-	 * @param string $mode The encrypt mode to use with the cipher
-	 * @param string $padding The padding type to use. Defaults to PAD_ZERO
-	 * @return void
-	 */
-	public function __construct($key, $cipher = self::CIPHER_AES_128, $mode = self::MODE_ECB, $padding = self::PAD_ZERO)
-	{
-		/*
+    // Ciphers
+    const CIPHER_3DES			= "3DES";
+    const CIPHER_3WAY			= "3-Way";
+    const CIPHER_AES_128		= "AES-128";
+    const CIPHER_AES_192		= "AES-192";
+    const CIPHER_AES_256		= "AES-256";
+    const CIPHER_ARC4			= "ARC4"; // Alternative RC4
+    const CIPHER_BLOWFISH		= "Blowfish";
+    const CIPHER_CAST_128		= "CAST-128";
+    const CIPHER_CAST_256		= "CAST-256";
+    const CIPHER_DES			= "DES";
+    const CIPHER_ENIGMA			= "Enigma";
+    const CIPHER_GOST			= "GOST";
+    const CIPHER_RC2			= "RC2";
+    const CIPHER_RIJNDAEL_128	= "Rijndael-128";
+    const CIPHER_RIJNDAEL_192	= "Rijndael-192";
+    const CIPHER_RIJNDAEL_256	= "Rijndael-256";
+    const CIPHER_SKIPJACK		= "Skipjack";
+    const CIPHER_SIMPLEXOR		= "SimpleXOR";
+    const CIPHER_VIGENERE		= "Vigenere"; // historical
+
+    // Modes
+    const MODE_CBC	= "CBC";
+    const MODE_CFB	= "CFB";  // 8 bit cfb mode
+    const MODE_CTR	= "CTR";
+    const MODE_ECB	= "ECB";
+    const MODE_NCFB	= "NCFB"; // blocksize cfb mode
+    const MODE_NOFB	= "NOFB"; // blocksize ofb mode
+    const MODE_OFB	= "OFB";  // 8 bit ofb mode
+    const MODE_PCBC	= "PCBC";
+    const MODE_RAW	= "Raw";  // raw encryption, with no mode
+    const MODE_STREAM = "Stream"; // used only for stream ciphers
+
+    // The source of random data used to create keys and IV's
+    // Used for PHP_Crypt::createKey(), PHP_Crypt::createIV()
+    const RAND			= "rand"; // uses mt_rand(), windows & unix
+    const RAND_DEV_RAND	= "/dev/random"; // unix only
+    const RAND_DEV_URAND= "/dev/urandom";// unix only
+    const RAND_WIN_COM	= "wincom";		 // windows only, COM extension
+    const RAND_DEFAULT_SZ = 32;			 // the default number of bytes returned
+
+    // Padding types
+    const PAD_ZERO			= 0;
+    const PAD_ANSI_X923		= 1;
+    const PAD_ISO_10126		= 2;
+    const PAD_PKCS7			= 3;
+    const PAD_ISO_7816_4	= 4;
+
+
+    /** @type object $cipher An instance of the cipher object selected */
+    private $cipher = null;
+
+    /** @type object $mode An instance of the mode object selected */
+    private $mode = null;
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key to use for the selected Cipher
+     * @param string $cipher The type of cipher to use
+     * @param string $mode The encrypt mode to use with the cipher
+     * @param string $padding The padding type to use. Defaults to PAD_ZERO
+     * @return void
+     */
+    public function __construct($key, $cipher = self::CIPHER_AES_128, $mode = self::MODE_ECB, $padding = self::PAD_ZERO)
+    {
+        /*
 		 * CIPHERS
 		 */
-		switch($cipher)
-		{
-		case self::CIPHER_3DES:
-			$this->cipher = new Cipher_3DES($key);
-			break;
+        switch($cipher)
+        {
+        case self::CIPHER_3DES:
+            $this->cipher = new Cipher_3DES($key);
+            break;
 
-		case self::CIPHER_3WAY:
-			$this->cipher = new Cipher_3WAY($key);
-			break;
+        case self::CIPHER_3WAY:
+            $this->cipher = new Cipher_3WAY($key);
+            break;
 
-		case self::CIPHER_AES_128:
-			$this->cipher = new Cipher_AES_128($key);
-			break;
+        case self::CIPHER_AES_128:
+            $this->cipher = new Cipher_AES_128($key);
+            break;
 
-		case self::CIPHER_AES_192:
-			$this->cipher = new Cipher_AES_192($key);
-			break;
+        case self::CIPHER_AES_192:
+            $this->cipher = new Cipher_AES_192($key);
+            break;
 
-		case self::CIPHER_AES_256:
-			$this->cipher = new Cipher_AES_256($key);
-			break;
+        case self::CIPHER_AES_256:
+            $this->cipher = new Cipher_AES_256($key);
+            break;
 
-		case self::CIPHER_ARC4: // an alternative to RC4
-			$this->cipher = new Cipher_ARC4($key);
-			break;
+        case self::CIPHER_ARC4: // an alternative to RC4
+            $this->cipher = new Cipher_ARC4($key);
+            break;
 
-		case self::CIPHER_BLOWFISH:
-			$this->cipher = new Cipher_Blowfish($key);
-			break;
+        case self::CIPHER_BLOWFISH:
+            $this->cipher = new Cipher_Blowfish($key);
+            break;
 
-		case self::CIPHER_CAST_128:
-			$this->cipher = new Cipher_CAST_128($key);
-			break;
+        case self::CIPHER_CAST_128:
+            $this->cipher = new Cipher_CAST_128($key);
+            break;
 
-		case self::CIPHER_CAST_256:
-			$this->cipher = new Cipher_CAST_256($key);
-			break;
+        case self::CIPHER_CAST_256:
+            $this->cipher = new Cipher_CAST_256($key);
+            break;
 
-		case self::CIPHER_DES:
-			$this->cipher = new Cipher_DES($key);
-			break;
+        case self::CIPHER_DES:
+            $this->cipher = new Cipher_DES($key);
+            break;
 
-		case self::CIPHER_ENIGMA:
-			$this->cipher = new Cipher_Enigma($key);
-			break;
+        case self::CIPHER_ENIGMA:
+            $this->cipher = new Cipher_Enigma($key);
+            break;
 
-		case self::CIPHER_GOST:
-			$this->cipher = new Cipher_GOST($key);
-			break;
+        case self::CIPHER_GOST:
+            $this->cipher = new Cipher_GOST($key);
+            break;
 
-		case self::CIPHER_RC2:
-			$this->cipher = new Cipher_RC2($key);
-			break;
+        case self::CIPHER_RC2:
+            $this->cipher = new Cipher_RC2($key);
+            break;
 
-		case self::CIPHER_RIJNDAEL_128:
-			$this->cipher = new Cipher_Rijndael_128($key);
-			break;
+        case self::CIPHER_RIJNDAEL_128:
+            $this->cipher = new Cipher_Rijndael_128($key);
+            break;
 
-		case self::CIPHER_RIJNDAEL_192:
-			$this->cipher = new Cipher_Rijndael_192($key);
-			break;
+        case self::CIPHER_RIJNDAEL_192:
+            $this->cipher = new Cipher_Rijndael_192($key);
+            break;
 
-		case self::CIPHER_RIJNDAEL_256:
-			$this->cipher = new Cipher_Rijndael_256($key);
-			break;
+        case self::CIPHER_RIJNDAEL_256:
+            $this->cipher = new Cipher_Rijndael_256($key);
+            break;
 
-		case self::CIPHER_SIMPLEXOR:
-			$this->cipher = new Cipher_Simple_XOR($key);
-			break;
+        case self::CIPHER_SIMPLEXOR:
+            $this->cipher = new Cipher_Simple_XOR($key);
+            break;
 
-		case self::CIPHER_SKIPJACK:
-			$this->cipher = new Cipher_Skipjack($key);
-			break;
+        case self::CIPHER_SKIPJACK:
+            $this->cipher = new Cipher_Skipjack($key);
+            break;
 
-		case self::CIPHER_VIGENERE:
-			$this->cipher = new Cipher_Vigenere($key);
-			break;
+        case self::CIPHER_VIGENERE:
+            $this->cipher = new Cipher_Vigenere($key);
+            break;
 
-		default:
-			trigger_error("$cipher is not a valid cipher", E_USER_WARNING);
-		}
+        default:
+            trigger_error("$cipher is not a valid cipher", E_USER_WARNING);
+        }
 
 
-		/*
+        /*
 		 * MODES
 		 */
-		switch($mode)
-		{
-		case self::MODE_CBC:
-			$this->mode = new Mode_CBC($this->cipher);
-			break;
-
-		case self::MODE_CFB:
-			$this->mode = new Mode_CFB($this->cipher);
-			break;
-
-		case self::MODE_CTR:
-			$this->mode = new Mode_CTR($this->cipher);
-			break;
-
-		case self::MODE_ECB:
-			$this->mode = new Mode_ECB($this->cipher);
-			break;
-
-		case self::MODE_NCFB:
-			$this->mode = new Mode_NCFB($this->cipher);
-			break;
-
-		case self::MODE_NOFB:
-			$this->mode = new Mode_NOFB($this->cipher);
-			break;
-
-		case self::MODE_OFB:
-			$this->mode = new Mode_OFB($this->cipher);
-			break;
-
-		case self::MODE_PCBC:
-			$this->mode = new Mode_PCBC($this->cipher);
-			break;
-
-		case self::MODE_RAW:
-			$this->mode = new Mode_RAW($this->cipher);
-			break;
-
-		case self::MODE_STREAM:
-			$this->mode = new Mode_Stream($this->cipher);
-			break;
-
-		default:
-			trigger_error("$mode is not a valid mode", E_USER_WARNING);
-		}
-
-		// set the default padding
-		$this->padding($padding);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-
-	}
-
-
-	/**
-	 * Encrypt a plain text message using the Mode and Cipher selected.
-	 * Some stream modes require this function to be called in a loop
-	 * which requires the use of $result parameter to retrieve
-	 * the decrypted data.
-	 *
-	 * @param string $text The plain text string
-	 * @return string The encrypted string
-	 */
-	public function encrypt($text)
-	{
-		// check that an iv is set, if required by the mode
-		$this->mode->checkIV();
-
-		// the encryption is done inside the mode
-		$this->mode->encrypt($text);
-		return $text;
-	}
-
-
-	/**
-	 * Decrypt an encrypted message using the Mode and Cipher selected.
-	 * Some stream modes require this function to be called in a loop
-	 * which requires the use of $result parameter to retrieve
-	 * the decrypted data.
-	 *
-	 * @param string $text The encrypted string
-	 * @return string The decrypted string
-	 */
-	public function decrypt($text)
-	{
-		// check that an iv is set, if required by the mode
-		$this->mode->checkIV();
-
-		// the decryption is done inside the mode
-		$this->mode->decrypt($text);
-		return $text;
-	}
-
-
-	/**
-	 * Return the cipher object being used
-	 *
-	 * @return object The Cipher object
-	 */
-	public function cipher()
-	{
-		return $this->cipher;
-	}
-
-
-	/**
-	 * Return the mode object being used
-	 *
-	 * @return object The Mode object
-	 */
-	public function mode()
-	{
-		return $this->mode;
-	}
-
-
-	/**
-	 * Returns the name of the cipher being used
-	 *
-	 * @return string The name of the cipher currently in use,
-	 *	it will be one of the predefined phpCrypt cipher constants
-	 */
-	public function cipherName()
-	{
-		return $this->cipher->name();
-	}
-
-
-	/**
-	 * Return the name of the mode being used
-	 *
-	 * @return string The name of the mode in use, it will
-	 * be one of the predefined phpCrypt mode constants
-	 */
-	public function modeName()
-	{
-		return $this->mode->name();
-	}
-
-
-	/**
-	 * Returns Ciphers required block size in bytes
-	 *
-	 * @return integer The cipher data block size, in bytes
-	 */
-	public function cipherBlockSize()
-	{
-		return $this->cipher->blockSize();
-	}
-
-
-	/**
-	 * Returns the cipher's required key size, in bytes
-	 *
-	 * @return integer The cipher's key size requirement, in bytes
-	 */
-	public function cipherKeySize()
-	{
-		return $this->cipher->keySize();
-	}
-
-
-	/**
-	 * Sets and/or returns the key to be used. Normally you set
-	 * the key in the phpCrypt constructor. This can be usefully
-	 * if you need to change the key on the fly and don't want
-	 * to create a new instance of phpCrypt.
-	 *
-	 * If the $key parameter is not given, this function will simply
-	 * return the key currently in use.
-	 *
-	 * @param string $key Optional, The key to set
-	 * @return string The key being used
-	 */
-	public function cipherKey($key = "")
-	{
-		return $this->cipher->key($key);
-	}
-
-
-	/**
-	 * A helper function which will create a random key. Calls
-	 * Core::randBytes(). By default it will use PHP_Crypt::RAND for
-	 * the random source of bytes, and return a PHP_Crypt::RAND_DEFAULT_SZ
-	 * byte string. There are 4 ways to create a random byte string by
-	 * setting the $src parameter:
-	 * PHP_Crypt::RAND - Default, uses mt_rand()
-	 * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
-	 * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
-	 * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
-	 *
-	 * @param string $src Optional, The source to use to create random bytes
-	 * @param integer $len Optional, The number of random bytes to return
-	 * @return string A random string of bytes
-	 */
-	public static function createKey($src = self::RAND, $len = self::RAND_DEFAULT_SZ)
-	{
-		return Core::randBytes($src, $len);
-	}
-
-
-	/**
-	 * Sets the IV to use. Note that you do not need to call
-	 * this function if creating an IV using createIV(). This
-	 * function is used when an IV has already been created
-	 * outside of phpCrypt and needs to be set. Alternatively
-	 * you can just pass the $iv parameter to the encrypt()
-	 * or decrypt() functions
-	 *
-	 * When the $iv parameter is not given, the function will
-	 * return the current IV being used. See createIV() if you
-	 * need to create an IV.
-	 *
-	 * @param string $iv Optional, The IV to use during Encryption/Decryption
-	 * @return void
-	 */
-	public function IV($iv = "")
-	{
-		return $this->mode->IV($iv);
-	}
-
-
-	/**
-	 * Creates an IV for the the Cipher selected, if one is required.
-	 * If you already have an IV to use, this function does not need
-	 * to be called, instead set it with setIV(). If you create an
-	 * IV with createIV(), you do not need to set it with setIV(),
-	 * as it is automatically set in this function
-	 *
-	 * $src values are:
-	 * PHP_Crypt::RAND - Default, uses mt_rand()
-	 * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
-	 * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
-	 * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
-	 *
-	 * @param string $src Optional, how the IV is generated
-	 * @return string The IV that was created, and set for the mode
-	 */
-	public function createIV($src = self::RAND)
-	{
-		return $this->mode->createIV($src);
-	}
-
-
-	/**
-	 * Sets the type of padding to be used within the specified Mode
-	 *
-	 * @param string $type One of the predefined padding types
-	 * @return void
-	 */
-	public function padding($type = "")
-	{
-		return $this->mode->padding($type);
-	}
+        switch($mode)
+        {
+        case self::MODE_CBC:
+            $this->mode = new Mode_CBC($this->cipher);
+            break;
+
+        case self::MODE_CFB:
+            $this->mode = new Mode_CFB($this->cipher);
+            break;
+
+        case self::MODE_CTR:
+            $this->mode = new Mode_CTR($this->cipher);
+            break;
+
+        case self::MODE_ECB:
+            $this->mode = new Mode_ECB($this->cipher);
+            break;
+
+        case self::MODE_NCFB:
+            $this->mode = new Mode_NCFB($this->cipher);
+            break;
+
+        case self::MODE_NOFB:
+            $this->mode = new Mode_NOFB($this->cipher);
+            break;
+
+        case self::MODE_OFB:
+            $this->mode = new Mode_OFB($this->cipher);
+            break;
+
+        case self::MODE_PCBC:
+            $this->mode = new Mode_PCBC($this->cipher);
+            break;
+
+        case self::MODE_RAW:
+            $this->mode = new Mode_RAW($this->cipher);
+            break;
+
+        case self::MODE_STREAM:
+            $this->mode = new Mode_Stream($this->cipher);
+            break;
+
+        default:
+            trigger_error("$mode is not a valid mode", E_USER_WARNING);
+        }
+
+        // set the default padding
+        $this->padding($padding);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+
+    }
+
+
+    /**
+     * Encrypt a plain text message using the Mode and Cipher selected.
+     * Some stream modes require this function to be called in a loop
+     * which requires the use of $result parameter to retrieve
+     * the decrypted data.
+     *
+     * @param string $text The plain text string
+     * @return string The encrypted string
+     */
+    public function encrypt($text)
+    {
+        // check that an iv is set, if required by the mode
+        $this->mode->checkIV();
+
+        // the encryption is done inside the mode
+        $this->mode->encrypt($text);
+        return $text;
+    }
+
+
+    /**
+     * Decrypt an encrypted message using the Mode and Cipher selected.
+     * Some stream modes require this function to be called in a loop
+     * which requires the use of $result parameter to retrieve
+     * the decrypted data.
+     *
+     * @param string $text The encrypted string
+     * @return string The decrypted string
+     */
+    public function decrypt($text)
+    {
+        // check that an iv is set, if required by the mode
+        $this->mode->checkIV();
+
+        // the decryption is done inside the mode
+        $this->mode->decrypt($text);
+        return $text;
+    }
+
+
+    /**
+     * Return the cipher object being used
+     *
+     * @return object The Cipher object
+     */
+    public function cipher()
+    {
+        return $this->cipher;
+    }
+
+
+    /**
+     * Return the mode object being used
+     *
+     * @return object The Mode object
+     */
+    public function mode()
+    {
+        return $this->mode;
+    }
+
+
+    /**
+     * Returns the name of the cipher being used
+     *
+     * @return string The name of the cipher currently in use,
+     *	it will be one of the predefined phpCrypt cipher constants
+     */
+    public function cipherName()
+    {
+        return $this->cipher->name();
+    }
+
+
+    /**
+     * Return the name of the mode being used
+     *
+     * @return string The name of the mode in use, it will
+     * be one of the predefined phpCrypt mode constants
+     */
+    public function modeName()
+    {
+        return $this->mode->name();
+    }
+
+
+    /**
+     * Returns Ciphers required block size in bytes
+     *
+     * @return integer The cipher data block size, in bytes
+     */
+    public function cipherBlockSize()
+    {
+        return $this->cipher->blockSize();
+    }
+
+
+    /**
+     * Returns the cipher's required key size, in bytes
+     *
+     * @return integer The cipher's key size requirement, in bytes
+     */
+    public function cipherKeySize()
+    {
+        return $this->cipher->keySize();
+    }
+
+
+    /**
+     * Sets and/or returns the key to be used. Normally you set
+     * the key in the phpCrypt constructor. This can be usefully
+     * if you need to change the key on the fly and don't want
+     * to create a new instance of phpCrypt.
+     *
+     * If the $key parameter is not given, this function will simply
+     * return the key currently in use.
+     *
+     * @param string $key Optional, The key to set
+     * @return string The key being used
+     */
+    public function cipherKey($key = "")
+    {
+        return $this->cipher->key($key);
+    }
+
+
+    /**
+     * A helper function which will create a random key. Calls
+     * Core::randBytes(). By default it will use PHP_Crypt::RAND for
+     * the random source of bytes, and return a PHP_Crypt::RAND_DEFAULT_SZ
+     * byte string. There are 4 ways to create a random byte string by
+     * setting the $src parameter:
+     * PHP_Crypt::RAND - Default, uses mt_rand()
+     * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
+     * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
+     * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
+     *
+     * @param string $src Optional, The source to use to create random bytes
+     * @param integer $len Optional, The number of random bytes to return
+     * @return string A random string of bytes
+     */
+    public static function createKey($src = self::RAND, $len = self::RAND_DEFAULT_SZ)
+    {
+        return Core::randBytes($src, $len);
+    }
+
+
+    /**
+     * Sets the IV to use. Note that you do not need to call
+     * this function if creating an IV using createIV(). This
+     * function is used when an IV has already been created
+     * outside of phpCrypt and needs to be set. Alternatively
+     * you can just pass the $iv parameter to the encrypt()
+     * or decrypt() functions
+     *
+     * When the $iv parameter is not given, the function will
+     * return the current IV being used. See createIV() if you
+     * need to create an IV.
+     *
+     * @param string $iv Optional, The IV to use during Encryption/Decryption
+     * @return void
+     */
+    public function IV($iv = "")
+    {
+        return $this->mode->IV($iv);
+    }
+
+
+    /**
+     * Creates an IV for the the Cipher selected, if one is required.
+     * If you already have an IV to use, this function does not need
+     * to be called, instead set it with setIV(). If you create an
+     * IV with createIV(), you do not need to set it with setIV(),
+     * as it is automatically set in this function
+     *
+     * $src values are:
+     * PHP_Crypt::RAND - Default, uses mt_rand()
+     * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
+     * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
+     * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
+     *
+     * @param string $src Optional, how the IV is generated
+     * @return string The IV that was created, and set for the mode
+     */
+    public function createIV($src = self::RAND)
+    {
+        return $this->mode->createIV($src);
+    }
+
+
+    /**
+     * Sets the type of padding to be used within the specified Mode
+     *
+     * @param string $type One of the predefined padding types
+     * @return void
+     */
+    public function padding($type = "")
+    {
+        return $this->mode->padding($type);
+    }
 }
 ?>

includes/libraries/phpcrypt/Mode.php

Indentation +269 added lines, -269 removed lines

@@ -36,299 +36,299 @@
  */
 abstract class Mode
 {
-	/**
-	 * @type object $cipher The cipher object used within the mode
-	 */
-	protected $cipher = null;
-
-	/**
-	 * @type string $iv The IV used for the mode, not all Modes
-	 * use an IV so this may be empty
-	 */
-	protected $iv = "";
-
-	/**
-	 * @type string $register For modes that use a register to do
-	 * encryption/decryption. This stores the unencrypted register.
-	 */
-	protected $register = "";
-
-	/**
-	 * @type string $enc_register For modes that use a register to do
-	 * encryption/decryption. This stores the encrypted register
-	 */
-	protected $enc_register = "";
-
-	/**
-	 * @type integer $block_size The byte size of the block to
-	 * encrypt/decrypt for the Mode
-	 */
-	private $block_size = 0;
-
-	/** @type string $mode_name The name of mode currently used */
-	private $mode_name = "";
-
-	/**
-	 * @type string $padding The type of padding to use when required.
-	 * Padding types are defined in phpCrypt class. Defaults to
-	 * PHP_Crypt::PAD_ZERO
-	 */
-	private $padding = PHP_Crypt::PAD_ZERO;
-
-
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher One of the phpCrypt encryption cipher objects
-	 * @param string $mode_name The name of phpCrypt's modes, as defined in the mode
-	 * @return void
-	 */
-	protected function __construct($mode_name, $cipher)
-	{
-		$this->name($mode_name);
-		$this->cipher($cipher);
-		$this->block_size = $this->cipher->blockSize();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	protected function __destruct()
-	{
-
-	}
-
-
-
-	/**********************************************************************
+    /**
+     * @type object $cipher The cipher object used within the mode
+     */
+    protected $cipher = null;
+
+    /**
+     * @type string $iv The IV used for the mode, not all Modes
+     * use an IV so this may be empty
+     */
+    protected $iv = "";
+
+    /**
+     * @type string $register For modes that use a register to do
+     * encryption/decryption. This stores the unencrypted register.
+     */
+    protected $register = "";
+
+    /**
+     * @type string $enc_register For modes that use a register to do
+     * encryption/decryption. This stores the encrypted register
+     */
+    protected $enc_register = "";
+
+    /**
+     * @type integer $block_size The byte size of the block to
+     * encrypt/decrypt for the Mode
+     */
+    private $block_size = 0;
+
+    /** @type string $mode_name The name of mode currently used */
+    private $mode_name = "";
+
+    /**
+     * @type string $padding The type of padding to use when required.
+     * Padding types are defined in phpCrypt class. Defaults to
+     * PHP_Crypt::PAD_ZERO
+     */
+    private $padding = PHP_Crypt::PAD_ZERO;
+
+
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher One of the phpCrypt encryption cipher objects
+     * @param string $mode_name The name of phpCrypt's modes, as defined in the mode
+     * @return void
+     */
+    protected function __construct($mode_name, $cipher)
+    {
+        $this->name($mode_name);
+        $this->cipher($cipher);
+        $this->block_size = $this->cipher->blockSize();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    protected function __destruct()
+    {
+
+    }
+
+
+
+    /**********************************************************************
 	 * ABSTRACT METHODS
 	 *
 	 * The abstract methods required by inheriting classes to implement
 	 **********************************************************************/
 
-	/**
-	 * All modes must have encrypt(), which implements
-	 * the mode using the cipher's encrypiton algorithm
-	 *
-	 * @param string $text A String to encrypt
-	 * @return boolean Always returns true
-	 */
-	abstract public function encrypt(&$text);
+    /**
+     * All modes must have encrypt(), which implements
+     * the mode using the cipher's encrypiton algorithm
+     *
+     * @param string $text A String to encrypt
+     * @return boolean Always returns true
+     */
+    abstract public function encrypt(&$text);
 
 
-	/**
-	 * All modes must have decrypt(), which implements
-	 * the mode using the cipher's encryption algorithm
-	 *
-	 * @param string $text A String to decrypt
-	 * @return boolean Always returns true
-	 */
-	abstract public function decrypt(&$text);
+    /**
+     * All modes must have decrypt(), which implements
+     * the mode using the cipher's encryption algorithm
+     *
+     * @param string $text A String to decrypt
+     * @return boolean Always returns true
+     */
+    abstract public function decrypt(&$text);
 
 
-	/**
-	 * Indicates whether or not a mode requires an IV
-	 *
-	 * @return boolean Always returns true or false
-	 */
-	abstract public function requiresIV();
+    /**
+     * Indicates whether or not a mode requires an IV
+     *
+     * @return boolean Always returns true or false
+     */
+    abstract public function requiresIV();
 
 
 
 
-	/**********************************************************************
+    /**********************************************************************
 	 * PUBLIC METHODS
 	 *
 	 **********************************************************************/
 
-	/**
-	 * Create an IV if the Mode used requires an IV.
-	 * The IV should be saved and used for Encryption/Decryption
-	 * of the same blocks of data.
-	 * There are 3 ways to auto generate an IV by setting $src parameter
-	 * PHP_Crypt::RAND - Default, uses mt_rand()
-	 * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
-	 * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
-	 * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
-	 *
-	 * @param string $src Optional, Sets how the IV is generated, must be
-	 *	one of the predefined PHP_Crypt RAND constants. Defaults to
-	 *	PHP_Crypt::RAND if none is given.
-	 * @return string The IV that is being used by the mode
-	 */
-	public function createIV($src = PHP_Crypt::RAND)
-	{
-		// if the mode does not use an IV, lets not waste time
-		if(!$this->requiresIV())
-			return false;
-
-		$iv = Core::randBytes($src, $this->block_size);
-		return $this->IV($iv);
-	}
-
-
-	/**
-	 * Sets or Returns an IV for the mode to use. If the $iv parameter
-	 * is not given, this function only returns the current IV in use.
-	 *
-	 * @param string $iv Optional, An IV to use for the mode and cipher selected
-	 * @return string The current IV being used
-	 */
-	public function IV($iv = null)
-	{
-		if($iv != null)
-		{
-			// check that the iv is the correct length,
-			$len = strlen($iv);
-			if($len != $this->block_size)
-			{
-				$msg = "Incorrect IV size. Supplied length: $len bytes, Required: {$this->block_size} bytes";
-				trigger_error($msg, E_USER_WARNING);
-			}
-
-			$this->clearRegisters();
-			$this->register = $iv;
-			$this->iv = $iv;
-		}
-
-		return $this->iv;
-	}
-
-
-	/**
-	 * Checks to see if the current mode requires an IV and that it is set
-	 * if it is required. Triggers E_USER_WARNING an IV is required and not set
-	 *
-	 * @return void
-	 */
-	public function checkIV()
-	{
-		if($this->requiresIV() && strlen($this->register) == 0)
-		{
-			$msg = strtoupper($this->mode_name)." mode requires an IV or the IV is empty";
-			trigger_error($msg, E_USER_WARNING);
-		}
-	}
-
-
-	/**
-	 * Sets and returns the name of the mode being used
-	 * If $name parameter is set, sets the mode. If
-	 * $name is not set, returns the current mode in use
-	 *
-	 * @param string $name Optional, One of the predefined
-	 * 	phpCrypt mode constant names
-	 * @return string One of the predefined phpCrypt mode
-	 * 	constant mode names
-	 */
-	public function name($name = "")
-	{
-		if($name != "")
-			$this->mode_name = $name;
-
-		return $this->mode_name;
-	}
-
-
-	/**
-	 * Sets or Returns the padding type used with the mode
-	 * If the $type parameter is not given, this function
-	 * returns the the padding type only.
-	 *
-	 * @param string $type One of the predefined padding types
-	 * @return void
-	 */
-	public function padding($type = "")
-	{
-		if($type != "")
-			$this->padding = $type;
-
-		return $this->padding;
-	}
-
-
-	/**
-	 * Returns or Sets the cipher object being used
-	 * If the $cipher parameter is set with a cipher object,
-	 * the cipher current cipher will be set to this cipher.
-	 * If the $cipher parameter is not set, returns the
-	 * current cipher object being used.
-	 *
-	 * @param object $cipher Optional, An object of type Cipher
-	 * @return object An object of type Cipher
-	 */
-	public function cipher($cipher = null)
-	{
-		if(is_object($cipher))
-			$this->cipher = $cipher;
-
-		return $this->cipher;
-	}
-
-
-
-
-	/**********************************************************************
+    /**
+     * Create an IV if the Mode used requires an IV.
+     * The IV should be saved and used for Encryption/Decryption
+     * of the same blocks of data.
+     * There are 3 ways to auto generate an IV by setting $src parameter
+     * PHP_Crypt::RAND - Default, uses mt_rand()
+     * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
+     * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
+     * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
+     *
+     * @param string $src Optional, Sets how the IV is generated, must be
+     *	one of the predefined PHP_Crypt RAND constants. Defaults to
+     *	PHP_Crypt::RAND if none is given.
+     * @return string The IV that is being used by the mode
+     */
+    public function createIV($src = PHP_Crypt::RAND)
+    {
+        // if the mode does not use an IV, lets not waste time
+        if(!$this->requiresIV())
+            return false;
+
+        $iv = Core::randBytes($src, $this->block_size);
+        return $this->IV($iv);
+    }
+
+
+    /**
+     * Sets or Returns an IV for the mode to use. If the $iv parameter
+     * is not given, this function only returns the current IV in use.
+     *
+     * @param string $iv Optional, An IV to use for the mode and cipher selected
+     * @return string The current IV being used
+     */
+    public function IV($iv = null)
+    {
+        if($iv != null)
+        {
+            // check that the iv is the correct length,
+            $len = strlen($iv);
+            if($len != $this->block_size)
+            {
+                $msg = "Incorrect IV size. Supplied length: $len bytes, Required: {$this->block_size} bytes";
+                trigger_error($msg, E_USER_WARNING);
+            }
+
+            $this->clearRegisters();
+            $this->register = $iv;
+            $this->iv = $iv;
+        }
+
+        return $this->iv;
+    }
+
+
+    /**
+     * Checks to see if the current mode requires an IV and that it is set
+     * if it is required. Triggers E_USER_WARNING an IV is required and not set
+     *
+     * @return void
+     */
+    public function checkIV()
+    {
+        if($this->requiresIV() && strlen($this->register) == 0)
+        {
+            $msg = strtoupper($this->mode_name)." mode requires an IV or the IV is empty";
+            trigger_error($msg, E_USER_WARNING);
+        }
+    }
+
+
+    /**
+     * Sets and returns the name of the mode being used
+     * If $name parameter is set, sets the mode. If
+     * $name is not set, returns the current mode in use
+     *
+     * @param string $name Optional, One of the predefined
+     * 	phpCrypt mode constant names
+     * @return string One of the predefined phpCrypt mode
+     * 	constant mode names
+     */
+    public function name($name = "")
+    {
+        if($name != "")
+            $this->mode_name = $name;
+
+        return $this->mode_name;
+    }
+
+
+    /**
+     * Sets or Returns the padding type used with the mode
+     * If the $type parameter is not given, this function
+     * returns the the padding type only.
+     *
+     * @param string $type One of the predefined padding types
+     * @return void
+     */
+    public function padding($type = "")
+    {
+        if($type != "")
+            $this->padding = $type;
+
+        return $this->padding;
+    }
+
+
+    /**
+     * Returns or Sets the cipher object being used
+     * If the $cipher parameter is set with a cipher object,
+     * the cipher current cipher will be set to this cipher.
+     * If the $cipher parameter is not set, returns the
+     * current cipher object being used.
+     *
+     * @param object $cipher Optional, An object of type Cipher
+     * @return object An object of type Cipher
+     */
+    public function cipher($cipher = null)
+    {
+        if(is_object($cipher))
+            $this->cipher = $cipher;
+
+        return $this->cipher;
+    }
+
+
+
+
+    /**********************************************************************
 	 * PROTECTED METHODS
 	 *
 	 **********************************************************************/
 
-	/**
-	 * Pads str so that final block is $block_bits in size, if the final block
-	 * is $block_bits, then an additional block is added that is $block_bits in size
-	 * The padding should be set by phpCrypt::setPadding()
-	 *
-	 * @param string $str the string to be padded
-	 * @return boolean Returns true
-	 */
-	protected function pad(&$str)
-	{
-		$len = strlen($str);
-		$bytes = $this->cipher->blockSize(); // returns bytes
-
-		// now determine the next multiple of blockSize(), then find
-		// the difference between that and the length of $str,
-		// this is how many padding bytes we will need
-		$num = ceil($len / $bytes) * $bytes;
-		$num = $num - $len;
-
-		Padding::pad($str, $num, $this->padding);
-		return true;
-	}
-
-
-	/**
-	 * Strip out the padded blocks created from Pad().
-	 * Padding type should be set by phpCrypt::setPadding()
-	 *
-	 * @param string $str the string to strip padding from
-	 * @return boolean Returns True
-	 */
-	protected function strip(&$str)
-	{
-		Padding::strip($str, $this->padding);
-		return true;
-	}
-
-
-	/**********************************************************************
+    /**
+     * Pads str so that final block is $block_bits in size, if the final block
+     * is $block_bits, then an additional block is added that is $block_bits in size
+     * The padding should be set by phpCrypt::setPadding()
+     *
+     * @param string $str the string to be padded
+     * @return boolean Returns true
+     */
+    protected function pad(&$str)
+    {
+        $len = strlen($str);
+        $bytes = $this->cipher->blockSize(); // returns bytes
+
+        // now determine the next multiple of blockSize(), then find
+        // the difference between that and the length of $str,
+        // this is how many padding bytes we will need
+        $num = ceil($len / $bytes) * $bytes;
+        $num = $num - $len;
+
+        Padding::pad($str, $num, $this->padding);
+        return true;
+    }
+
+
+    /**
+     * Strip out the padded blocks created from Pad().
+     * Padding type should be set by phpCrypt::setPadding()
+     *
+     * @param string $str the string to strip padding from
+     * @return boolean Returns True
+     */
+    protected function strip(&$str)
+    {
+        Padding::strip($str, $this->padding);
+        return true;
+    }
+
+
+    /**********************************************************************
 	 * PRIVATE METHODS
 	 *
 	 **********************************************************************/
 
-	/**
-	 * Clears the registers used for some modes
-	 *
-	 * @return void
-	 */
-	private function clearRegisters()
-	{
-		$this->register = "";
-		$this->enc_register = "";
-	}
+    /**
+     * Clears the registers used for some modes
+     *
+     * @return void
+     */
+    private function clearRegisters()
+    {
+        $this->register = "";
+        $this->enc_register = "";
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/3DES.php

Indentation +201 added lines, -201 removed lines

@@ -43,209 +43,209 @@
  */
 class Cipher_3DES extends Cipher_DES
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 8; // 64 bits
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 8; // 64 bits
 
-	/** @type integer BYTES_KEY The size of the key. The key can be
+    /** @type integer BYTES_KEY The size of the key. The key can be
 	8, 16, or 24 bytes but gets expanded to 24 bytes before used */
-	const BYTES_KEY = 24;
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		$key_len = strlen($key);
-
-		if($key_len == 8 || $key_len == 16)
-			$key = self::expandKey($key, $key_len);
-		else if($key_len < self::BYTES_KEY)
-		{
-			$msg  = PHP_Crypt::CIPHER_3DES." requires an 8, 16, or 24 byte key. ";
-			$msg .= "$key_len bytes received.";
-			trigger_error($msg, E_USER_WARNING);
-		}
-		// else if the key is longer than 24 bytes, phpCrypt will shorten it
-
-		// set the 3DES key, note that we call __construct1() not __construct()
-		// this is a second contructor we created for classes that extend the
-		// DES class
-		parent::__construct1(PHP_Crypt::CIPHER_3DES, $key, self::BYTES_KEY);
-
-		// 3DES requires that data is 64 bits
-		$this->blockSize(self::BYTES_BLOCK);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data using TripleDES
-	 * For encryption 3DES takes a 192 bit key, splits
-	 * it into 3 64 bit parts, and then does the following
-	 * DES ENCRYPT(key1) -> DES DECRYPT(key2) -> DES ENCRYPT(key3)
-	 *
-	 * @param string $data A plain text string
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$blocksz = $this->blockSize();
-
-		for($i = 0; $i < 3; ++$i)
-		{
-			$key = substr($this->key(), ($i * 8), $blocksz);
-			$this->keyPermutation($key);
-
-			if($i % 2) // round 1
-				$this->operation(parent::DECRYPT);
-			else // rounds 0 and 2
-				$this->operation(parent::ENCRYPT);
-
-			$this->des($text);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypt a TripleDES encrypted string
-	 * For decryption 3DES takes a 192 bit key, splits
-	 * it into 3 64 bit parts, and then does the following
-	 * DES DECRYPT(key1) -> DES ENCRYPT(key2) -> DES DECRYPT(key3)
-	 *
-	 * @param string $encrypted A DES encrypted string
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$blocksz = $this->blockSize();
-
-		for($i = 2; $i >= 0; --$i)
-		{
-			$key = substr($this->key(), ($i * 8), $blocksz);
-			$this->keyPermutation($key);
-
-			if($i % 2) // round 1
-				$this->operation(parent::ENCRYPT);
-			else // round 0 and 2
-				$this->operation(parent::DECRYPT);
-
-			$this->des($text);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * We overload the DES::keyPermutation() function so it takes
-	 * a 64 bit key as a parameter. This is because 3DES uses a 192 bit
-	 * key which is split into 3 64 bit parts, each of which must be
-	 * passed through the keyPermutation() function
-	 * Key permutation, based on tables $_pc1 and $_pc2
-	 * Create 16 subkeys, each of which is 48-bits long.
-	 * NOTE: The $key parameter is required, however because PHP expects
-	 * an overloaded method to contain the same number of parameters
-	 * (when E_STRICT is set) as the parent class, we make it optional
-	 * to shut the 'error' up
-	 *
-	 * @param string $key A 64 bit key
-	 * @return void
-	 */
-	private function keyPermutation($key = "")
-	{
-		$this->sub_keys = array();
-		$pc1m = array();
-		$pcr = array();
-		$c = array();
-		$d = array();
-
-		// convert the key to binary
-		$binkey = parent::str2Bin($key);
-
-		// reduce the key down to 56bits based on table $_pc1
-		for($i = 0; $i < 56; ++$i)
-		{
-			$pos = parent::$_pc1[$i] - 1;
+    const BYTES_KEY = 24;
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        $key_len = strlen($key);
+
+        if($key_len == 8 || $key_len == 16)
+            $key = self::expandKey($key, $key_len);
+        else if($key_len < self::BYTES_KEY)
+        {
+            $msg  = PHP_Crypt::CIPHER_3DES." requires an 8, 16, or 24 byte key. ";
+            $msg .= "$key_len bytes received.";
+            trigger_error($msg, E_USER_WARNING);
+        }
+        // else if the key is longer than 24 bytes, phpCrypt will shorten it
+
+        // set the 3DES key, note that we call __construct1() not __construct()
+        // this is a second contructor we created for classes that extend the
+        // DES class
+        parent::__construct1(PHP_Crypt::CIPHER_3DES, $key, self::BYTES_KEY);
+
+        // 3DES requires that data is 64 bits
+        $this->blockSize(self::BYTES_BLOCK);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data using TripleDES
+     * For encryption 3DES takes a 192 bit key, splits
+     * it into 3 64 bit parts, and then does the following
+     * DES ENCRYPT(key1) -> DES DECRYPT(key2) -> DES ENCRYPT(key3)
+     *
+     * @param string $data A plain text string
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $blocksz = $this->blockSize();
+
+        for($i = 0; $i < 3; ++$i)
+        {
+            $key = substr($this->key(), ($i * 8), $blocksz);
+            $this->keyPermutation($key);
+
+            if($i % 2) // round 1
+                $this->operation(parent::DECRYPT);
+            else // rounds 0 and 2
+                $this->operation(parent::ENCRYPT);
+
+            $this->des($text);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypt a TripleDES encrypted string
+     * For decryption 3DES takes a 192 bit key, splits
+     * it into 3 64 bit parts, and then does the following
+     * DES DECRYPT(key1) -> DES ENCRYPT(key2) -> DES DECRYPT(key3)
+     *
+     * @param string $encrypted A DES encrypted string
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $blocksz = $this->blockSize();
+
+        for($i = 2; $i >= 0; --$i)
+        {
+            $key = substr($this->key(), ($i * 8), $blocksz);
+            $this->keyPermutation($key);
+
+            if($i % 2) // round 1
+                $this->operation(parent::ENCRYPT);
+            else // round 0 and 2
+                $this->operation(parent::DECRYPT);
+
+            $this->des($text);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * We overload the DES::keyPermutation() function so it takes
+     * a 64 bit key as a parameter. This is because 3DES uses a 192 bit
+     * key which is split into 3 64 bit parts, each of which must be
+     * passed through the keyPermutation() function
+     * Key permutation, based on tables $_pc1 and $_pc2
+     * Create 16 subkeys, each of which is 48-bits long.
+     * NOTE: The $key parameter is required, however because PHP expects
+     * an overloaded method to contain the same number of parameters
+     * (when E_STRICT is set) as the parent class, we make it optional
+     * to shut the 'error' up
+     *
+     * @param string $key A 64 bit key
+     * @return void
+     */
+    private function keyPermutation($key = "")
+    {
+        $this->sub_keys = array();
+        $pc1m = array();
+        $pcr = array();
+        $c = array();
+        $d = array();
+
+        // convert the key to binary
+        $binkey = parent::str2Bin($key);
+
+        // reduce the key down to 56bits based on table $_pc1
+        for($i = 0; $i < 56; ++$i)
+        {
+            $pos = parent::$_pc1[$i] - 1;
             $pc1m[$i] = $binkey[$pos];
-		}
-
-		// split $pc1m in half (C0 and D0)
-		$c[0] = array_slice($pc1m, 0, 28);
-		$d[0] = array_slice($pc1m, 28, 28);
-
-		// now that $c[0] and $d[0] are defined, create 16 blocks for Cn and Dn
-		// where 1 <= n <= 16
-		for($i = 1; $i <= 16; ++$i)
-		{
-			// now set the next Cn and Dn as the previous Cn and Dn
-			$c[$i] = $c[$i-1];
-			$d[$i] = $d[$i-1];
-
-			for($j = 0; $j < parent::$_key_sched[$i-1]; ++$j)
-			{
-				// do a left shift, move each bit one place to the left,
-				// except for the first bit, which is cycled to the end
-				// of the block.
-				$c[$i][] = array_shift($c[$i]);
-				$d[$i][] = array_shift($d[$i]);
-			}
-
-			// We now form the sub_keys (Kn), for 1<=n<=16, by applying the
-			// following permutation table to each of the concatenated
-			// pairs CnDn. Each pair has 56 bits, but PC-2 only uses 48
-			// of these.
-			$CnDn = array_merge($c[$i], $d[$i]);
-			$this->sub_keys[$i-1] = "";
-			for($j = 0; $j < 48; ++$j)
-				$this->sub_keys[$i-1] .= $CnDn[parent::$_pc2[$j] - 1];
-		}
-
-		// the sub_keys are created, we are done with the key permutation
-	}
-
-
-	/**
-	 * Triple DES accepts an 8, 16, or 24 bytes key. If the key is
-	 * 8 or 16 bytes, it is expanded to 24 bytes
-	 * An 8 byte key is expanded by repeating it 3 times to make a 24
-	 * byte key
-	 * A 16 byte key add the first 8 bytes to the end of the string
-	 * to make a 24 byte key
-	 *
-	 * @param string $key The 8 or 16 byte key to expand
-	 * @return string If the key given is 8 or 16 bytes it returns the
-	 *	expanded 24 byte key, else it returns the original key unexpanded
-	 */
-	private static function expandKey($key, $len)
-	{
-		// if we were given an 8 byte key, repeat it
-		// 3 times to produce a 24 byte key
-		if($len == 8)
-			$key = str_repeat($key, 3);
-
-		// if we were given a 16 byte key, add the first
-		// 8 bytes to the end of the key to produce 24 bytes
-		if($len == 16)
-			$key .= substr($key, 0, 8);
-
-		// return the key
-		return $key;
-	}
+        }
+
+        // split $pc1m in half (C0 and D0)
+        $c[0] = array_slice($pc1m, 0, 28);
+        $d[0] = array_slice($pc1m, 28, 28);
+
+        // now that $c[0] and $d[0] are defined, create 16 blocks for Cn and Dn
+        // where 1 <= n <= 16
+        for($i = 1; $i <= 16; ++$i)
+        {
+            // now set the next Cn and Dn as the previous Cn and Dn
+            $c[$i] = $c[$i-1];
+            $d[$i] = $d[$i-1];
+
+            for($j = 0; $j < parent::$_key_sched[$i-1]; ++$j)
+            {
+                // do a left shift, move each bit one place to the left,
+                // except for the first bit, which is cycled to the end
+                // of the block.
+                $c[$i][] = array_shift($c[$i]);
+                $d[$i][] = array_shift($d[$i]);
+            }
+
+            // We now form the sub_keys (Kn), for 1<=n<=16, by applying the
+            // following permutation table to each of the concatenated
+            // pairs CnDn. Each pair has 56 bits, but PC-2 only uses 48
+            // of these.
+            $CnDn = array_merge($c[$i], $d[$i]);
+            $this->sub_keys[$i-1] = "";
+            for($j = 0; $j < 48; ++$j)
+                $this->sub_keys[$i-1] .= $CnDn[parent::$_pc2[$j] - 1];
+        }
+
+        // the sub_keys are created, we are done with the key permutation
+    }
+
+
+    /**
+     * Triple DES accepts an 8, 16, or 24 bytes key. If the key is
+     * 8 or 16 bytes, it is expanded to 24 bytes
+     * An 8 byte key is expanded by repeating it 3 times to make a 24
+     * byte key
+     * A 16 byte key add the first 8 bytes to the end of the string
+     * to make a 24 byte key
+     *
+     * @param string $key The 8 or 16 byte key to expand
+     * @return string If the key given is 8 or 16 bytes it returns the
+     *	expanded 24 byte key, else it returns the original key unexpanded
+     */
+    private static function expandKey($key, $len)
+    {
+        // if we were given an 8 byte key, repeat it
+        // 3 times to produce a 24 byte key
+        if($len == 8)
+            $key = str_repeat($key, 3);
+
+        // if we were given a 16 byte key, add the first
+        // 8 bytes to the end of the key to produce 24 bytes
+        if($len == 16)
+            $key .= substr($key, 0, 8);
+
+        // return the key
+        return $key;
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/AES256.php

Indentation +26 added lines, -26 removed lines

@@ -38,35 +38,35 @@
  */
 class Cipher_AES_256 extends Cipher_Rijndael_128
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 16; // 128 bits;
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 16; // 128 bits;
 
-	/** @type integer BITS_KEY The size of the key, in bytes */
-	const BYTES_KEY = 32; // 256 bits;
+    /** @type integer BITS_KEY The size of the key, in bytes */
+    const BYTES_KEY = 32; // 256 bits;
 
-	/**
-	 * Constructor
-	 * Sets the key used for encryption.
-	 *
-	 * @param string $key string containing the user supplied encryption key
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// Setup AES by calling the second constructor in Rijndael_128
-		// The block size is set here too, since all AES implementations use 128 bit blocks
-		parent::__construct1(PHP_Crypt::CIPHER_AES_256, $key, self::BYTES_KEY);
-	}
+    /**
+     * Constructor
+     * Sets the key used for encryption.
+     *
+     * @param string $key string containing the user supplied encryption key
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // Setup AES by calling the second constructor in Rijndael_128
+        // The block size is set here too, since all AES implementations use 128 bit blocks
+        parent::__construct1(PHP_Crypt::CIPHER_AES_256, $key, self::BYTES_KEY);
+    }
 
 
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/SimpleXOR.php

Indentation +96 added lines, -96 removed lines

@@ -45,101 +45,101 @@
  */
 class Cipher_Simple_XOR extends Cipher
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 1; // 8 bits
-
-
-	/**
-	 * Constructor
-	 * Sets the key used for encryption. Also sets the requied block size
-	 *
-	 * @param string $key string containing the user supplied encryption key
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// SimpleXOR does not have a key size requirement
-		parent::__construct(PHP_Crypt::CIPHER_SIMPLEXOR, $key);
-
-		// required block size in bits
-		$this->blockSize(self::BYTES_BLOCK);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypts data using an XOR encryption scheme
-	 *
-	 * @param string $text A string to encrypt
-	 * @return boolean Always returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->operation(parent::ENCRYPT);
-		return $this->simpleXOR($text);
-	}
-
-
-	/**
-	 * Decrypts data encrypted with SimpleXOR::Encrypt()
-	 *
-	 * @param string $text An encrypted string to decrypt
-	 * @return boolean Always returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$this->operation(parent::DECRYPT);
-		return $this->simpleXOR($text);
-	}
-
-
-	/**
-	 * Because XOR Encryption uses the same algorithm to encrypt and decrypt,
-	 * this function contains the code to do both. The SimpleXOR::Encrypt()
-	 * and SimpleXOR::Decrypt() function above just call this function
-	 *
-	 * @param string $input
-	 * @return boolean Always returns true
-	 */
-	private function simpleXOR(&$text)
-	{
-		$pos = 0;
-		$max = strlen($text);
-		$key = $this->key();
-
-		for($i = 0; $i < $max; ++$i)
-		{
-			// if the current position in the key reaches the end of the key,
-			// start over at position 0 of the key
-			if($pos >= $this->keySize())
-				$pos = 0;
-
-			$text[$i] = $text[$i] ^ $key[$pos];
-			++$pos;
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Indicates that this is stream cipher
-	 *
-	 * @return integer Returns Cipher::STREAM
-	 */
-	public function type()
-	{
-		return parent::STREAM;
-	}
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 1; // 8 bits
+
+
+    /**
+     * Constructor
+     * Sets the key used for encryption. Also sets the requied block size
+     *
+     * @param string $key string containing the user supplied encryption key
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // SimpleXOR does not have a key size requirement
+        parent::__construct(PHP_Crypt::CIPHER_SIMPLEXOR, $key);
+
+        // required block size in bits
+        $this->blockSize(self::BYTES_BLOCK);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypts data using an XOR encryption scheme
+     *
+     * @param string $text A string to encrypt
+     * @return boolean Always returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->operation(parent::ENCRYPT);
+        return $this->simpleXOR($text);
+    }
+
+
+    /**
+     * Decrypts data encrypted with SimpleXOR::Encrypt()
+     *
+     * @param string $text An encrypted string to decrypt
+     * @return boolean Always returns true
+     */
+    public function decrypt(&$text)
+    {
+        $this->operation(parent::DECRYPT);
+        return $this->simpleXOR($text);
+    }
+
+
+    /**
+     * Because XOR Encryption uses the same algorithm to encrypt and decrypt,
+     * this function contains the code to do both. The SimpleXOR::Encrypt()
+     * and SimpleXOR::Decrypt() function above just call this function
+     *
+     * @param string $input
+     * @return boolean Always returns true
+     */
+    private function simpleXOR(&$text)
+    {
+        $pos = 0;
+        $max = strlen($text);
+        $key = $this->key();
+
+        for($i = 0; $i < $max; ++$i)
+        {
+            // if the current position in the key reaches the end of the key,
+            // start over at position 0 of the key
+            if($pos >= $this->keySize())
+                $pos = 0;
+
+            $text[$i] = $text[$i] ^ $key[$pos];
+            ++$pos;
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Indicates that this is stream cipher
+     *
+     * @return integer Returns Cipher::STREAM
+     */
+    public function type()
+    {
+        return parent::STREAM;
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/Enigma.php

Indentation +214 added lines, -214 removed lines

@@ -46,219 +46,219 @@
  */
 class Cipher_Enigma extends Cipher
 {
-	const MASK = 0377;
-
-	/** @type integer ROTORSZ The size of $t1,$t2,$t3,$deck */
-	const ROTORSZ = 256;
-
-	/** @type array $t1 An array of chars, ROTORSZ size */
-	private $t1 = array();
-
-	/** @type array $t2 An array of chars, ROTORSZ size */
-	private $t2 = array();
-
-	/** @type array $t3 An array of chars, ROTORSZ size */
-	private $t3 = array();
-
-	/** @type array $deck An array of chars, ROTORSZ size */
-	private $deck = array();
-
-	private $n1 = 0;
-	private $n2 = 0;
-	private $nr1 = 0;
-	private $nr2 = 0;
-
-	/** @type string $xkey Stores the modified key */
-	private $xkey = "";
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		parent::__construct(PHP_Crypt::CIPHER_ENIGMA, $key, strlen($key));
-
-		$this->createKey();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data using Enigma
-	 *
-	 * @param string $str A plain text string of any length
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$str)
-	{
-		$this->operation(parent::ENCRYPT);
-		return $this->enigma($str);
-	}
-
-
-	/**
-	 * Decrypt an Enigma encrypted string
-	 *
-	 * @param string $str A Enigma encrypted string
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$str)
-	{
-		$this->operation(parent::DECRYPT);
-		return $this->enigma($str);
-	}
-
-
-	/**
-	 * Peforms the actual Enigma encryption/decryption. Since
-	 * the algorithm is the same for both, we do it all in
-	 * this one function
-	 *
-	 * @param string $str A string to encrypt or decrypt
-	 * @return boolean Returns true
-	 */
-	private function enigma(&$str)
-	{
-		// zero out the counters
-		$this->n1 = 0;
-		$this->n2 = 0;
-		$this->nr1 = 0;
-		$this->nr2 = 0;
-
-		$max = strlen($str);
-		for($j = 0; $j < $max; ++$j)
-		{
-			$i = ord($str[$j]);
-			$this->nr1 = $this->n1;
-
-			$pos1 = ($i + $this->nr1) & self::MASK;
-			$pos3 = ($this->t1[$pos1] + $this->nr2) & self::MASK;
-			$pos2 = ($this->t3[$pos3] - $this->nr2) & self::MASK;
-			$i = $this->t2[$pos2] - $this->nr1;
-
-			$str[$j] = chr($i);
-			$this->n1++;
-
-			if($this->n1 == self::ROTORSZ)
-			{
-				$this->n1 = 0;
-				$this->n2++;
-
-				if($this->n2 == self::ROTORSZ)
-					$this->n2 = 0;
-
-				$this->nr2 = $this->n2;
-			}
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * The code for this function was translated to PHP from mcrypt's enigma.c,
-	 * I was not able to find sufficient documentation to create my own
-	 * version of this function.
-	 * Enigma requires a 13 byte key, this function will
-	 * lengthen the key to get it to 13 bytes long if it's short. It also
-	 * Sets $deck, and $t1, $t2, $t3 which I think are the Enigma rotors.
-	 *
-	 * @return void
-	 */
-	private function createKey()
-	{
-		$this->deck = array();
-		$this->t1 = array();
-		$this->t2 = array_fill(0, self::ROTORSZ, 0);
-		$this->t3 = $this->t2;
-		$this->xkey = $this->key();
-		$klen = $this->keySize();
-
-		// get the key to exactly 13 bytes if it's less than 13
-		if($klen < 13)
-			$this->xkey = str_pad($this->xkey, 13, chr(0), STR_PAD_RIGHT);
-
-		$seed = 123;
-		for($i = 0; $i < 13; ++$i)
-			$seed = parent::sInt32($seed) * ord($this->xkey[$i]) + $i;
-
-		// sets $t1 and $deck
-		for($i = 0; $i < self::ROTORSZ; ++$i)
-		{
-			$this->t1[] = $i;
-			$this->deck[] = $i;
-		}
-
-		// sets $t3
-		for($i = 0; $i < self::ROTORSZ; ++$i)
-		{
-			// make sure the return values are 32 bit
-			$seed = 5 * parent::sInt32($seed) + ord($this->xkey[$i % 13]);
-			$seed = parent::sInt32($seed);
-
-			// force the returned value to be an unsigned int
-			//$random = parent::uint32($seed % 65521);
-			$random = parent::uInt($seed % 65521);
-
-			$k = self::ROTORSZ - 1 - $i;
-			$ic = ($random & self::MASK) % ($k + 1);
-
-			// make sure the returned value is an unsigned int
-			$random = parent::uInt($random >> 8);
-
-			$temp = $this->t1[$k];
-			$this->t1[$k] = $this->t1[$ic];
-			$this->t1[$ic] = $temp;
-			if($this->t3[$k] != 0)
-				continue;
-
-			$ic = ($random & self::MASK) % $k;
-			while($this->t3[$ic] != 0)
-				$ic = ($ic + 1) % $k;
-
-			$this->t3[$k] = $ic;
-			$this->t3[$ic] = $k;
-		}
-
-		// sets $t2
-		for($i = 0; $i < self::ROTORSZ; ++$i)
-		{
-			$pos = $this->t1[$i] & self::MASK;
-			$this->t2[$pos] = $i;
-		}
-
-		// now convert $t1, $t2, $t3, $deck values to signed chars,
-		// PHP's chr() function returns an unsigned char, so we have
-		// to use use our own
-		$this->t1   = array_map("parent::sChar", $this->t1);
-		$this->t2   = array_map("parent::sChar", $this->t2);
-		$this->t3   = array_map("parent::sChar", $this->t3);
-		$this->deck = array_map("parent::sChar", $this->deck);
-	}
-
-
-	/**
-	 * Indicates this is a stream cipher
-	 *
-	 * @return integer Returns Cipher::STREAM
-	 */
-	public function type()
-	{
-		return parent::STREAM;
-	}
+    const MASK = 0377;
+
+    /** @type integer ROTORSZ The size of $t1,$t2,$t3,$deck */
+    const ROTORSZ = 256;
+
+    /** @type array $t1 An array of chars, ROTORSZ size */
+    private $t1 = array();
+
+    /** @type array $t2 An array of chars, ROTORSZ size */
+    private $t2 = array();
+
+    /** @type array $t3 An array of chars, ROTORSZ size */
+    private $t3 = array();
+
+    /** @type array $deck An array of chars, ROTORSZ size */
+    private $deck = array();
+
+    private $n1 = 0;
+    private $n2 = 0;
+    private $nr1 = 0;
+    private $nr2 = 0;
+
+    /** @type string $xkey Stores the modified key */
+    private $xkey = "";
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        parent::__construct(PHP_Crypt::CIPHER_ENIGMA, $key, strlen($key));
+
+        $this->createKey();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data using Enigma
+     *
+     * @param string $str A plain text string of any length
+     * @return boolean Returns true
+     */
+    public function encrypt(&$str)
+    {
+        $this->operation(parent::ENCRYPT);
+        return $this->enigma($str);
+    }
+
+
+    /**
+     * Decrypt an Enigma encrypted string
+     *
+     * @param string $str A Enigma encrypted string
+     * @return boolean Returns true
+     */
+    public function decrypt(&$str)
+    {
+        $this->operation(parent::DECRYPT);
+        return $this->enigma($str);
+    }
+
+
+    /**
+     * Peforms the actual Enigma encryption/decryption. Since
+     * the algorithm is the same for both, we do it all in
+     * this one function
+     *
+     * @param string $str A string to encrypt or decrypt
+     * @return boolean Returns true
+     */
+    private function enigma(&$str)
+    {
+        // zero out the counters
+        $this->n1 = 0;
+        $this->n2 = 0;
+        $this->nr1 = 0;
+        $this->nr2 = 0;
+
+        $max = strlen($str);
+        for($j = 0; $j < $max; ++$j)
+        {
+            $i = ord($str[$j]);
+            $this->nr1 = $this->n1;
+
+            $pos1 = ($i + $this->nr1) & self::MASK;
+            $pos3 = ($this->t1[$pos1] + $this->nr2) & self::MASK;
+            $pos2 = ($this->t3[$pos3] - $this->nr2) & self::MASK;
+            $i = $this->t2[$pos2] - $this->nr1;
+
+            $str[$j] = chr($i);
+            $this->n1++;
+
+            if($this->n1 == self::ROTORSZ)
+            {
+                $this->n1 = 0;
+                $this->n2++;
+
+                if($this->n2 == self::ROTORSZ)
+                    $this->n2 = 0;
+
+                $this->nr2 = $this->n2;
+            }
+        }
+
+        return true;
+    }
+
+
+    /**
+     * The code for this function was translated to PHP from mcrypt's enigma.c,
+     * I was not able to find sufficient documentation to create my own
+     * version of this function.
+     * Enigma requires a 13 byte key, this function will
+     * lengthen the key to get it to 13 bytes long if it's short. It also
+     * Sets $deck, and $t1, $t2, $t3 which I think are the Enigma rotors.
+     *
+     * @return void
+     */
+    private function createKey()
+    {
+        $this->deck = array();
+        $this->t1 = array();
+        $this->t2 = array_fill(0, self::ROTORSZ, 0);
+        $this->t3 = $this->t2;
+        $this->xkey = $this->key();
+        $klen = $this->keySize();
+
+        // get the key to exactly 13 bytes if it's less than 13
+        if($klen < 13)
+            $this->xkey = str_pad($this->xkey, 13, chr(0), STR_PAD_RIGHT);
+
+        $seed = 123;
+        for($i = 0; $i < 13; ++$i)
+            $seed = parent::sInt32($seed) * ord($this->xkey[$i]) + $i;
+
+        // sets $t1 and $deck
+        for($i = 0; $i < self::ROTORSZ; ++$i)
+        {
+            $this->t1[] = $i;
+            $this->deck[] = $i;
+        }
+
+        // sets $t3
+        for($i = 0; $i < self::ROTORSZ; ++$i)
+        {
+            // make sure the return values are 32 bit
+            $seed = 5 * parent::sInt32($seed) + ord($this->xkey[$i % 13]);
+            $seed = parent::sInt32($seed);
+
+            // force the returned value to be an unsigned int
+            //$random = parent::uint32($seed % 65521);
+            $random = parent::uInt($seed % 65521);
+
+            $k = self::ROTORSZ - 1 - $i;
+            $ic = ($random & self::MASK) % ($k + 1);
+
+            // make sure the returned value is an unsigned int
+            $random = parent::uInt($random >> 8);
+
+            $temp = $this->t1[$k];
+            $this->t1[$k] = $this->t1[$ic];
+            $this->t1[$ic] = $temp;
+            if($this->t3[$k] != 0)
+                continue;
+
+            $ic = ($random & self::MASK) % $k;
+            while($this->t3[$ic] != 0)
+                $ic = ($ic + 1) % $k;
+
+            $this->t3[$k] = $ic;
+            $this->t3[$ic] = $k;
+        }
+
+        // sets $t2
+        for($i = 0; $i < self::ROTORSZ; ++$i)
+        {
+            $pos = $this->t1[$i] & self::MASK;
+            $this->t2[$pos] = $i;
+        }
+
+        // now convert $t1, $t2, $t3, $deck values to signed chars,
+        // PHP's chr() function returns an unsigned char, so we have
+        // to use use our own
+        $this->t1   = array_map("parent::sChar", $this->t1);
+        $this->t2   = array_map("parent::sChar", $this->t2);
+        $this->t3   = array_map("parent::sChar", $this->t3);
+        $this->deck = array_map("parent::sChar", $this->deck);
+    }
+
+
+    /**
+     * Indicates this is a stream cipher
+     *
+     * @return integer Returns Cipher::STREAM
+     */
+    public function type()
+    {
+        return parent::STREAM;
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/Rijndael256.php

Indentation +28 added lines, -28 removed lines

@@ -38,39 +38,39 @@
  */
 class Cipher_Rijndael_256 extends Cipher_Rijndael
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 32; // 256 bits
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 32; // 256 bits
 
-	//const BITS_KEY = 0;
+    //const BITS_KEY = 0;
 
 
-	/**
-	 * Constructor
-	 * Sets the key used for encryption. Also sets the requied block size
-	 *
-	 * @param string $key string containing the user supplied encryption key
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// Set up the key
-		parent::__construct(PHP_Crypt::CIPHER_RIJNDAEL_256, $key);
+    /**
+     * Constructor
+     * Sets the key used for encryption. Also sets the requied block size
+     *
+     * @param string $key string containing the user supplied encryption key
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // Set up the key
+        parent::__construct(PHP_Crypt::CIPHER_RIJNDAEL_256, $key);
 
-		// required block size in bits
-		$this->blockSize(self::BYTES_BLOCK);
+        // required block size in bits
+        $this->blockSize(self::BYTES_BLOCK);
 
-		// expand the key now that we know the key size, and the bit size
-		$this->expandKey();
-	}
+        // expand the key now that we know the key size, and the bit size
+        $this->expandKey();
+    }
 
 
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
 }