nilsteampassnet / TeamPass

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 string
-	 */
-	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 string
+     */
+    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/modes/Raw.php

Indentation +61 added lines, -61 removed lines

@@ -39,76 +39,76 @@
  */
 class Mode_Raw extends Mode
 {
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher one of the phpCrypt encryption cipher objects
-	 * @return void
-	 */
-	public function __construct($cipher)
-	{
-		parent::__construct(PHP_Crypt::MODE_RAW, $cipher);
-	}
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher one of the phpCrypt encryption cipher objects
+     * @return void
+     */
+    public function __construct($cipher)
+    {
+        parent::__construct(PHP_Crypt::MODE_RAW, $cipher);
+    }
 
 
-	/**
-	 * Constructor used by classes that extend this class
-	 * Used by Mode_Stream, which extends this class
-	 *
-	 * @param object $cipher One of phpCrypts cipher objects
-	 * @param integer $mode The mode constant identifier
-	 * @return void
-	 */
-	protected function __construct1($mode, $cipher)
-	{
-		parent::__construct($mode, $cipher);
-	}
+    /**
+     * Constructor used by classes that extend this class
+     * Used by Mode_Stream, which extends this class
+     *
+     * @param object $cipher One of phpCrypts cipher objects
+     * @param integer $mode The mode constant identifier
+     * @return void
+     */
+    protected function __construct1($mode, $cipher)
+    {
+        parent::__construct($mode, $cipher);
+    }
 
 
-	/**
-	 * Destructor
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
+    /**
+     * Destructor
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
 
 
-	/**
-	 * Encrypts an the string using the Cipher with no Mode
-	 * NOTE: The data in $text must be the exact length required by the Cipher
-	 *
-	 * @return boolean Always returns false
-	 */
-	public function encrypt(&$text)
-	{
-		$this->cipher->encrypt($text);
-		return true;
-	}
+    /**
+     * Encrypts an the string using the Cipher with no Mode
+     * NOTE: The data in $text must be the exact length required by the Cipher
+     *
+     * @return boolean Always returns false
+     */
+    public function encrypt(&$text)
+    {
+        $this->cipher->encrypt($text);
+        return true;
+    }
 
 
-	/**
-	 * Decrypts one block of cipher text, not using any mode.
-	 * NOTE: The data in $text must be the exact length required by the Cipher
-	 *
-	 * @return boolean Always returns false
-	 */
-	public function decrypt(&$text)
-	{
-		$this->cipher->decrypt($text);
-		return true;
-	}
+    /**
+     * Decrypts one block of cipher text, not using any mode.
+     * NOTE: The data in $text must be the exact length required by the Cipher
+     *
+     * @return boolean Always returns false
+     */
+    public function decrypt(&$text)
+    {
+        $this->cipher->decrypt($text);
+        return true;
+    }
 
 
-	/**
-	 * This mode does not require an IV
-	 *
-	 * @return boolean false
-	 */
-	public function requiresIV()
-	{
-		return false;
-	}
+    /**
+     * This mode does not require an IV
+     *
+     * @return boolean false
+     */
+    public function requiresIV()
+    {
+        return false;
+    }
 }
 ?>

includes/libraries/phpcrypt/modes/ECB.php

Indentation +101 added lines, -101 removed lines

@@ -36,106 +36,106 @@
  */
 class Mode_ECB extends Mode
 {
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher one of the phpCrypt encryption cipher objects
-	 * @return void
-	 */
-	public function __construct($cipher)
-	{
-		parent::__construct(PHP_Crypt::MODE_ECB, $cipher);
-
-		// this works with only block Ciphers
-		if ($cipher->type() != Cipher::BLOCK)
-			trigger_error("ECB mode requires a block cipher", E_USER_WARNING);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypts an the entire string $plain_text using the cipher passed
-	 * to the constructor in ECB mode
-	 *
-	 * @param string $text The string to be encrypted in ECB mode
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->pad($text);
-		$blocksz = $this->cipher->blockSize();
-
-		$max = strlen($text) / $blocksz;
-		for ($i = 0; $i < $max; ++$i)
-		{
-			// get the current position within $text
-			$pos = $i * $blocksz;
-
-			// grab a block of text
-			$block = substr($text, $pos, $blocksz);
-
-			// encrypt the block
-			$this->cipher->encrypt($block);
-
-			// replace the plain text with the cipher text
-			$text = substr_replace($text, $block, $pos, $blocksz);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypts an the entire string $plain_text using the cipher passed
-	 * to the constructor in ECB mode
-	 *
-	 * @param string $text The string to be decrypted in ECB mode
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$blocksz = $this->cipher->blockSize();
-
-		$max = strlen($text) / $blocksz;
-		for ($i = 0; $i < $max; ++$i)
-		{
-			// get the current position within $text
-			$pos = $i * $blocksz;
-
-			// get a block of cipher text
-			$block = substr($text, $pos, $blocksz);
-
-			// decrypt the block
-			$this->cipher->decrypt($block);
-
-			// replace the block of cipher text with plain text
-			$text = substr_replace($text, $block, $pos, $blocksz);
-		}
-
-		$this->strip($text);
-		return true;
-	}
-
-
-	/**
-	 * This mode does not require an IV
-	 *
-	 * @return boolean Returns false
-	 */
-	public function requiresIV()
-	{
-		return false;
-	}
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher one of the phpCrypt encryption cipher objects
+     * @return void
+     */
+    public function __construct($cipher)
+    {
+        parent::__construct(PHP_Crypt::MODE_ECB, $cipher);
+
+        // this works with only block Ciphers
+        if ($cipher->type() != Cipher::BLOCK)
+            trigger_error("ECB mode requires a block cipher", E_USER_WARNING);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypts an the entire string $plain_text using the cipher passed
+     * to the constructor in ECB mode
+     *
+     * @param string $text The string to be encrypted in ECB mode
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->pad($text);
+        $blocksz = $this->cipher->blockSize();
+
+        $max = strlen($text) / $blocksz;
+        for ($i = 0; $i < $max; ++$i)
+        {
+            // get the current position within $text
+            $pos = $i * $blocksz;
+
+            // grab a block of text
+            $block = substr($text, $pos, $blocksz);
+
+            // encrypt the block
+            $this->cipher->encrypt($block);
+
+            // replace the plain text with the cipher text
+            $text = substr_replace($text, $block, $pos, $blocksz);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypts an the entire string $plain_text using the cipher passed
+     * to the constructor in ECB mode
+     *
+     * @param string $text The string to be decrypted in ECB mode
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $blocksz = $this->cipher->blockSize();
+
+        $max = strlen($text) / $blocksz;
+        for ($i = 0; $i < $max; ++$i)
+        {
+            // get the current position within $text
+            $pos = $i * $blocksz;
+
+            // get a block of cipher text
+            $block = substr($text, $pos, $blocksz);
+
+            // decrypt the block
+            $this->cipher->decrypt($block);
+
+            // replace the block of cipher text with plain text
+            $text = substr_replace($text, $block, $pos, $blocksz);
+        }
+
+        $this->strip($text);
+        return true;
+    }
+
+
+    /**
+     * This mode does not require an IV
+     *
+     * @return boolean Returns false
+     */
+    public function requiresIV()
+    {
+        return false;
+    }
 }
 ?>

install/js/crypt/aes.class.php

Indentation +52 added lines, -52 removed lines

@@ -40,80 +40,80 @@
     for ($i=0; $i<4*$Nb; $i++) $output[$i] = $state[$i%4][floor($i/4)];
 
     return $output;
-  }
+    }
 
-  /**
-   * @param integer $rnd
-   * @param integer $Nb
-   */
-  private static function addRoundKey($state, $w, $rnd, $Nb) {  // xor Round Key into state S [é5.1.4]
+    /**
+     * @param integer $rnd
+     * @param integer $Nb
+     */
+    private static function addRoundKey($state, $w, $rnd, $Nb) {  // xor Round Key into state S [é5.1.4]
     for ($r=0; $r<4; $r++) {
-      for ($c=0; $c<$Nb; $c++) $state[$r][$c] ^= $w[$rnd*4+$c][$r];
+        for ($c=0; $c<$Nb; $c++) $state[$r][$c] ^= $w[$rnd*4+$c][$r];
     }
 
     return $state;
-  }
+    }
 
-  /**
-   * @param integer $Nb
-   */
-  private static function subBytes($s, $Nb) {    // apply SBox to state S [é5.1.1]
+    /**
+     * @param integer $Nb
+     */
+    private static function subBytes($s, $Nb) {    // apply SBox to state S [é5.1.1]
     for ($r=0; $r<4; $r++) {
-      for ($c=0; $c<$Nb; $c++) {
-          $s[$r][$c] = self::$sBox[$s[$r][$c]];
-      }
+        for ($c=0; $c<$Nb; $c++) {
+            $s[$r][$c] = self::$sBox[$s[$r][$c]];
+        }
     }
 
     return $s;
-  }
+    }
 
-  /**
-   * @param integer $Nb
-   */
-  private static function shiftRows($s, $Nb) {    // shift row r of state S left by r bytes [é5.1.2]
+    /**
+     * @param integer $Nb
+     */
+    private static function shiftRows($s, $Nb) {    // shift row r of state S left by r bytes [é5.1.2]
     $t = array(4);
     for ($r=1; $r<4; $r++) {
-      for ($c=0; $c<4; $c++) {
-          $t[$c] = $s[$r][($c+$r)%$Nb];
-      }
-      // shift into temp copy
-      for ($c=0; $c<4; $c++) {
-          $s[$r][$c] = $t[$c];
-      }
-      // and copy back
+        for ($c=0; $c<4; $c++) {
+            $t[$c] = $s[$r][($c+$r)%$Nb];
+        }
+        // shift into temp copy
+        for ($c=0; $c<4; $c++) {
+            $s[$r][$c] = $t[$c];
+        }
+        // and copy back
     }          // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES):
     return $s;  // see fp.gladman.plus.com/cryptography_technology/rijndael/aes.spec.311.pdf
-  }
+    }
 
-  /**
-   * @param integer $Nb
-   */
-  private static function mixColumns($s, $Nb) {   // combine bytes of each col of state S [é5.1.3]
+    /**
+     * @param integer $Nb
+     */
+    private static function mixColumns($s, $Nb) {   // combine bytes of each col of state S [é5.1.3]
     for ($c=0; $c<4; $c++) {
-      $a = array(4);  // 'a' is a copy of the current column from 's'
-      $b = array(4);  // 'b' is aé{02} in GF(2^8)
-      for ($i=0; $i<4; $i++) {
+        $a = array(4);  // 'a' is a copy of the current column from 's'
+        $b = array(4);  // 'b' is aé{02} in GF(2^8)
+        for ($i=0; $i<4; $i++) {
         $a[$i] = $s[$i][$c];
         $b[$i] = $s[$i][$c]&0x80 ? $s[$i][$c]<<1 ^ 0x011b : $s[$i][$c]<<1;
-      }
-      // a[n] ^ b[n] is aé{03} in GF(2^8)
-      $s[0][$c] = $b[0] ^ $a[1] ^ $b[1] ^ $a[2] ^ $a[3]; // 2*a0 + 3*a1 + a2 + a3
-      $s[1][$c] = $a[0] ^ $b[1] ^ $a[2] ^ $b[2] ^ $a[3]; // a0 * 2*a1 + 3*a2 + a3
-      $s[2][$c] = $a[0] ^ $a[1] ^ $b[2] ^ $a[3] ^ $b[3]; // a0 + a1 + 2*a2 + 3*a3
-      $s[3][$c] = $a[0] ^ $b[0] ^ $a[1] ^ $a[2] ^ $b[3]; // 3*a0 + a1 + a2 + 2*a3
+        }
+        // a[n] ^ b[n] is aé{03} in GF(2^8)
+        $s[0][$c] = $b[0] ^ $a[1] ^ $b[1] ^ $a[2] ^ $a[3]; // 2*a0 + 3*a1 + a2 + a3
+        $s[1][$c] = $a[0] ^ $b[1] ^ $a[2] ^ $b[2] ^ $a[3]; // a0 * 2*a1 + 3*a2 + a3
+        $s[2][$c] = $a[0] ^ $a[1] ^ $b[2] ^ $a[3] ^ $b[3]; // a0 + a1 + 2*a2 + 3*a3
+        $s[3][$c] = $a[0] ^ $b[0] ^ $a[1] ^ $a[2] ^ $b[3]; // 3*a0 + a1 + a2 + 2*a3
     }
 
     return $s;
-  }
-
-  /**
-   * Key expansion for Rijndael cipher(): performs key expansion on cipher key
-   * to generate a key schedule
-   *
-   * @param key cipher key byte-array (16 bytes)
-   * @return    key schedule as 2D byte-array (Nr+1 x Nb bytes)
-   */
-  public static function keyExpansion($key) {  // generate Key Schedule from Cipher Key [é5.2]
+    }
+
+    /**
+     * Key expansion for Rijndael cipher(): performs key expansion on cipher key
+     * to generate a key schedule
+     *
+     * @param key cipher key byte-array (16 bytes)
+     * @return    key schedule as 2D byte-array (Nr+1 x Nb bytes)
+     */
+    public static function keyExpansion($key) {  // generate Key Schedule from Cipher Key [é5.2]
     $Nb = 4;              // block size (in words): no of columns in state (fixed at 4 for AES)
     $Nk = count($key)/4;  // key length (in words): 4/6/8 for 128/192/256-bit keys
     $Nr = $Nk + 6;        // no of rounds: 10/12/14 for 128/192/256-bit keys

install/js/crypt/aesctr.class.php

Indentation +24 added lines, -24 removed lines

@@ -7,19 +7,19 @@ 
 
 class AesCtr extends Aes
 {
-  /**
-   * Encrypt a text using AES encryption in Counter mode of operation
-   *  - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
-   *
-   * Unicode multi-byte character safe
-   *
-   * @param plaintext source text to be encrypted
-   * @param password  the password to use to generate a key
-   * @param nBits     number of bits to be used in the key (128, 192, or 256)
-   * @return          string text
-   */
-  public static function encrypt($plaintext, $password, $nBits)
-  {
+    /**
+     * Encrypt a text using AES encryption in Counter mode of operation
+     *  - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
+     *
+     * Unicode multi-byte character safe
+     *
+     * @param plaintext source text to be encrypted
+     * @param password  the password to use to generate a key
+     * @param nBits     number of bits to be used in the key (128, 192, or 256)
+     * @return          string text
+     */
+    public static function encrypt($plaintext, $password, $nBits)
+    {
     $blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
     if (!($nBits==128 || $nBits==192 || $nBits==256)) {
         return '';
@@ -87,18 +87,18 @@ 
     $ciphertext = base64_encode($ciphertext);
 
     return $ciphertext;
-  }
+    }
 
-  /**
-   * Decrypt a text encrypted by AES in counter mode of operation
-   *
-   * @param ciphertext source text to be decrypted
-   * @param password   the password to use to generate a key
-   * @param nBits      number of bits to be used in the key (128, 192, or 256)
-   * @return           string text
-   */
-  public static function decrypt($ciphertext, $password, $nBits)
-  {
+    /**
+     * Decrypt a text encrypted by AES in counter mode of operation
+     *
+     * @param ciphertext source text to be decrypted
+     * @param password   the password to use to generate a key
+     * @param nBits      number of bits to be used in the key (128, 192, or 256)
+     * @return           string text
+     */
+    public static function decrypt($ciphertext, $password, $nBits)
+    {
     $blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
     if (!($nBits==128 || $nBits==192 || $nBits==256)) {
         return '';