silverstripe / silverstripe-hybridsessions

tests/CookieStoreTest.php

Indentation +55 added lines, -55 removed lines

@@ -9,69 +9,69 @@
 
 class CookieStoreTest extends AbstractTest
 {
-    protected function getStore()
-    {
-        $store = Injector::inst()->get(CookieStore::class);
-        $store->setKey(uniqid());
-        $store->open(TempFolder::getTempFolder(BASE_PATH) . '/' . __CLASS__, 'SESSIONCOOKIE');
+	protected function getStore()
+	{
+		$store = Injector::inst()->get(CookieStore::class);
+		$store->setKey(uniqid());
+		$store->open(TempFolder::getTempFolder(BASE_PATH) . '/' . __CLASS__, 'SESSIONCOOKIE');
 
-        return $store;
-    }
+		return $store;
+	}
 
-    public function testStoreLargeData()
-    {
-        $session = uniqid();
-        $store = $this->getStore();
+	public function testStoreLargeData()
+	{
+		$session = uniqid();
+		$store = $this->getStore();
 
-        // Test new session is blank
-        $result = $store->read($session);
-        $this->assertEmpty($result);
+		// Test new session is blank
+		$result = $store->read($session);
+		$this->assertEmpty($result);
 
-        // Save data against session
-        $data1 = array(
-            'Large' => str_repeat('A', 600),
-            'Content' => str_repeat('B', 600)
-        );
-        $store->write($session, serialize($data1));
-        $result = $store->read($session);
+		// Save data against session
+		$data1 = array(
+			'Large' => str_repeat('A', 600),
+			'Content' => str_repeat('B', 600)
+		);
+		$store->write($session, serialize($data1));
+		$result = $store->read($session);
 
-        // Cookies should not try to store data that large
-        $this->assertEmpty($result);
-    }
+		// Cookies should not try to store data that large
+		$this->assertEmpty($result);
+	}
 
-    /**
-     * Ensure that subsequent reads without the necessary write do not report data
-     */
-    public function testReadInvalidatesData()
-    {
-        $session = uniqid();
-        $store = $this->getStore();
+	/**
+	 * Ensure that subsequent reads without the necessary write do not report data
+	 */
+	public function testReadInvalidatesData()
+	{
+		$session = uniqid();
+		$store = $this->getStore();
 
-        // Test new session is blank
-        $result = $store->read($session);
-        $this->assertEmpty($result);
+		// Test new session is blank
+		$result = $store->read($session);
+		$this->assertEmpty($result);
 
-        // Save data against session
-        $data1 = array(
-            'Color' => 'red',
-            'Animal' => 'elephant'
-        );
-        $store->write($session, serialize($data1));
-        $result = $store->read($session);
-        $this->assertEquals($data1, unserialize($result));
+		// Save data against session
+		$data1 = array(
+			'Color' => 'red',
+			'Animal' => 'elephant'
+		);
+		$store->write($session, serialize($data1));
+		$result = $store->read($session);
+		$this->assertEquals($data1, unserialize($result));
 
-        // Since we have read the data into the result, the application could modify this content
-        // and be unable to write it back due to headers being sent. We should thus assume
-        // that subsequent reads without a successful write do not purport to have valid data
-        $data1['Color'] = 'blue';
-        $result = $store->read($session);
-        $this->assertEmpty($result);
+		// Since we have read the data into the result, the application could modify this content
+		// and be unable to write it back due to headers being sent. We should thus assume
+		// that subsequent reads without a successful write do not purport to have valid data
+		$data1['Color'] = 'blue';
+		$result = $store->read($session);
+		$this->assertEmpty($result);
 
-        // Check that writing to cookie fails after headers are sent and these results remain
-        // invalidated
-        TestCookieStore::$override_headers_sent = true;
-        $store->write($session, serialize($data1));
-        $result = $store->read($session);
-        $this->assertEmpty($result);
-    }
+		// Check that writing to cookie fails after headers are sent and these results remain
+		// invalidated
+		TestCookieStore::$override_headers_sent = true;
+		$store->write($session, serialize($data1));
+		$result = $store->read($session);
+		$this->assertEmpty($result);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -13,7 +13,7 @@
     {
         $store = Injector::inst()->get(CookieStore::class);
         $store->setKey(uniqid());
-        $store->open(TempFolder::getTempFolder(BASE_PATH) . '/' . __CLASS__, 'SESSIONCOOKIE');
+        $store->open(TempFolder::getTempFolder(BASE_PATH).'/'.__CLASS__, 'SESSIONCOOKIE');
 
         return $store;
     }

src/Crypto/McryptCrypto.php

Indentation +105 added lines, -105 removed lines

@@ -8,109 +8,109 @@
  */
 class McryptCrypto implements CryptoHandler
 {
-    protected $key;
-
-    protected $ivSize;
-
-    protected $keySize;
-
-    protected $salt;
-
-    protected $saltedKey;
-
-    /**
-     * @return string
-     */
-    public function getKey()
-    {
-        return $this->key;
-    }
-
-    /**
-     * @return string
-     */
-    public function getSalt()
-    {
-        return $this->salt;
-    }
-
-    /**
-     * @param $key a per-site secret string which is used as the base encryption key.
-     * @param $salt a per-session random string which is used as a salt to generate a per-session key
-     *
-     * The base encryption key needs to stay secret. If an attacker ever gets it, they can read their session,
-     * and even modify & re-sign it.
-     *
-     * The salt is a random per-session string that is used with the base encryption key to create a per-session key.
-     * This (amongst other things) makes sure an attacker can't use a known-plaintext attack to guess the key.
-     *
-     * Normally we could create a salt on encryption, send it to the client as part of the session (it doesn't
-     * need to remain secret), then use the returned salt to decrypt. But we already have the Session ID which makes
-     * a great salt, so no need to generate & handle another one.
-     */
-    public function __construct($key, $salt)
-    {
-        $this->ivSize = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_CBC);
-        $this->keySize = mcrypt_get_key_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_CBC);
-
-        $this->key = $key;
-        $this->salt = $salt;
-        $this->saltedKey = hash_pbkdf2('sha256', $this->key, $this->salt, 1000, $this->keySize, true);
-    }
-
-    /**
-     * Encrypt and then sign some cleartext
-     *
-     * @param $cleartext - The cleartext to encrypt and sign
-     * @return string - The encrypted-and-signed message as base64 ASCII.
-     */
-    public function encrypt($cleartext)
-    {
-        $iv = mcrypt_create_iv($this->ivSize, MCRYPT_DEV_URANDOM);
-
-        $enc = mcrypt_encrypt(
-            MCRYPT_RIJNDAEL_256,
-            $this->saltedKey,
-            $cleartext,
-            MCRYPT_MODE_CBC,
-            $iv
-        );
-
-        $hash = hash_hmac('sha256', $enc, $this->saltedKey);
-
-        return base64_encode($iv . $hash . $enc);
-    }
-
-    /**
-     * Check the signature on an encrypted-and-signed message, and if valid
-     * decrypt the content
-     *
-     * @param $data - The encrypted-and-signed message as base64 ASCII
-     *
-     * @return bool|string - The decrypted cleartext or false if signature failed
-     */
-    public function decrypt($data)
-    {
-        $data = base64_decode($data);
-
-        $iv   = substr($data, 0, $this->ivSize);
-        $hash = substr($data, $this->ivSize, 64);
-        $enc  = substr($data, $this->ivSize + 64);
-
-        $cleartext = rtrim(mcrypt_decrypt(
-            MCRYPT_RIJNDAEL_256,
-            $this->saltedKey,
-            $enc,
-            MCRYPT_MODE_CBC,
-            $iv
-        ), "\x00");
-
-        // Needs to be after decrypt so it always runs, to avoid timing attack
-        $gen_hash = hash_hmac('sha256', $enc, $this->saltedKey);
-
-        if ($gen_hash == $hash) {
-            return $cleartext;
-        }
-        return false;
-    }
+	protected $key;
+
+	protected $ivSize;
+
+	protected $keySize;
+
+	protected $salt;
+
+	protected $saltedKey;
+
+	/**
+	 * @return string
+	 */
+	public function getKey()
+	{
+		return $this->key;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getSalt()
+	{
+		return $this->salt;
+	}
+
+	/**
+	 * @param $key a per-site secret string which is used as the base encryption key.
+	 * @param $salt a per-session random string which is used as a salt to generate a per-session key
+	 *
+	 * The base encryption key needs to stay secret. If an attacker ever gets it, they can read their session,
+	 * and even modify & re-sign it.
+	 *
+	 * The salt is a random per-session string that is used with the base encryption key to create a per-session key.
+	 * This (amongst other things) makes sure an attacker can't use a known-plaintext attack to guess the key.
+	 *
+	 * Normally we could create a salt on encryption, send it to the client as part of the session (it doesn't
+	 * need to remain secret), then use the returned salt to decrypt. But we already have the Session ID which makes
+	 * a great salt, so no need to generate & handle another one.
+	 */
+	public function __construct($key, $salt)
+	{
+		$this->ivSize = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_CBC);
+		$this->keySize = mcrypt_get_key_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_CBC);
+
+		$this->key = $key;
+		$this->salt = $salt;
+		$this->saltedKey = hash_pbkdf2('sha256', $this->key, $this->salt, 1000, $this->keySize, true);
+	}
+
+	/**
+	 * Encrypt and then sign some cleartext
+	 *
+	 * @param $cleartext - The cleartext to encrypt and sign
+	 * @return string - The encrypted-and-signed message as base64 ASCII.
+	 */
+	public function encrypt($cleartext)
+	{
+		$iv = mcrypt_create_iv($this->ivSize, MCRYPT_DEV_URANDOM);
+
+		$enc = mcrypt_encrypt(
+			MCRYPT_RIJNDAEL_256,
+			$this->saltedKey,
+			$cleartext,
+			MCRYPT_MODE_CBC,
+			$iv
+		);
+
+		$hash = hash_hmac('sha256', $enc, $this->saltedKey);
+
+		return base64_encode($iv . $hash . $enc);
+	}
+
+	/**
+	 * Check the signature on an encrypted-and-signed message, and if valid
+	 * decrypt the content
+	 *
+	 * @param $data - The encrypted-and-signed message as base64 ASCII
+	 *
+	 * @return bool|string - The decrypted cleartext or false if signature failed
+	 */
+	public function decrypt($data)
+	{
+		$data = base64_decode($data);
+
+		$iv   = substr($data, 0, $this->ivSize);
+		$hash = substr($data, $this->ivSize, 64);
+		$enc  = substr($data, $this->ivSize + 64);
+
+		$cleartext = rtrim(mcrypt_decrypt(
+			MCRYPT_RIJNDAEL_256,
+			$this->saltedKey,
+			$enc,
+			MCRYPT_MODE_CBC,
+			$iv
+		), "\x00");
+
+		// Needs to be after decrypt so it always runs, to avoid timing attack
+		$gen_hash = hash_hmac('sha256', $enc, $this->saltedKey);
+
+		if ($gen_hash == $hash) {
+			return $cleartext;
+		}
+		return false;
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -78,7 +78,7 @@
 
         $hash = hash_hmac('sha256', $enc, $this->saltedKey);
 
-        return base64_encode($iv . $hash . $enc);
+        return base64_encode($iv.$hash.$enc);
     }
 
     /**

src/Crypto/OpenSSLCrypto.php

Indentation +76 added lines, -76 removed lines

@@ -8,90 +8,90 @@
  */
 class OpenSSLCrypto implements CryptoHandler
 {
-    protected $key;
+	protected $key;
 
-    protected $salt;
+	protected $salt;
 
-    protected $saltedKey;
+	protected $saltedKey;
 
-    /**
-     * @return string
-     */
-    public function getKey()
-    {
-        return $this->key;
-    }
+	/**
+	 * @return string
+	 */
+	public function getKey()
+	{
+		return $this->key;
+	}
 
-    /**
-     * @return string
-     */
-    public function getSalt()
-    {
-        return $this->salt;
-    }
+	/**
+	 * @return string
+	 */
+	public function getSalt()
+	{
+		return $this->salt;
+	}
 
-    /**
-     * @param string $key a per-site secret string which is used as the base encryption key.
-     * @param string $salt a per-session random string which is used as a salt to generate a per-session key
-     *
-     * The base encryption key needs to stay secret. If an attacker ever gets it, they can read their session,
-     * and even modify & re-sign it.
-     *
-     * The salt is a random per-session string that is used with the base encryption key to create a per-session key.
-     * This (amongst other things) makes sure an attacker can't use a known-plaintext attack to guess the key.
-     *
-     * Normally we could create a salt on encryption, send it to the client as part of the session (it doesn't
-     * need to remain secret), then use the returned salt to decrypt. But we already have the Session ID which makes
-     * a great salt, so no need to generate & handle another one.
-     */
-    public function __construct($key, $salt)
-    {
-        $this->key = $key;
-        $this->salt = $salt;
-        $this->saltedKey = hash_pbkdf2('sha256', $this->key, $this->salt, 1000, 0, true);
-    }
+	/**
+	 * @param string $key a per-site secret string which is used as the base encryption key.
+	 * @param string $salt a per-session random string which is used as a salt to generate a per-session key
+	 *
+	 * The base encryption key needs to stay secret. If an attacker ever gets it, they can read their session,
+	 * and even modify & re-sign it.
+	 *
+	 * The salt is a random per-session string that is used with the base encryption key to create a per-session key.
+	 * This (amongst other things) makes sure an attacker can't use a known-plaintext attack to guess the key.
+	 *
+	 * Normally we could create a salt on encryption, send it to the client as part of the session (it doesn't
+	 * need to remain secret), then use the returned salt to decrypt. But we already have the Session ID which makes
+	 * a great salt, so no need to generate & handle another one.
+	 */
+	public function __construct($key, $salt)
+	{
+		$this->key = $key;
+		$this->salt = $salt;
+		$this->saltedKey = hash_pbkdf2('sha256', $this->key, $this->salt, 1000, 0, true);
+	}
 
-    /**
-     * Encrypt and then sign some cleartext
-     *
-     * @param string $cleartext - The cleartext to encrypt and sign
-     * @return string - The encrypted-and-signed message as base64 ASCII.
-     */
-    public function encrypt($cleartext)
-    {
-        $cipher = "AES-256-CBC";
-        $ivlen = openssl_cipher_iv_length($cipher);
-        $iv = openssl_random_pseudo_bytes($ivlen);
-        $ciphertext_raw = openssl_encrypt($cleartext, $cipher, $this->saltedKey, $options = OPENSSL_RAW_DATA, $iv);
-        $hmac = hash_hmac('sha256', $ciphertext_raw, $this->saltedKey, $as_binary = true);
-        $ciphertext = base64_encode($iv . $hmac . $ciphertext_raw);
+	/**
+	 * Encrypt and then sign some cleartext
+	 *
+	 * @param string $cleartext - The cleartext to encrypt and sign
+	 * @return string - The encrypted-and-signed message as base64 ASCII.
+	 */
+	public function encrypt($cleartext)
+	{
+		$cipher = "AES-256-CBC";
+		$ivlen = openssl_cipher_iv_length($cipher);
+		$iv = openssl_random_pseudo_bytes($ivlen);
+		$ciphertext_raw = openssl_encrypt($cleartext, $cipher, $this->saltedKey, $options = OPENSSL_RAW_DATA, $iv);
+		$hmac = hash_hmac('sha256', $ciphertext_raw, $this->saltedKey, $as_binary = true);
+		$ciphertext = base64_encode($iv . $hmac . $ciphertext_raw);
 
-        return base64_encode($iv . $hmac . $ciphertext_raw);
-    }
+		return base64_encode($iv . $hmac . $ciphertext_raw);
+	}
 
-    /**
-     * Check the signature on an encrypted-and-signed message, and if valid
-     * decrypt the content
-     *
-     * @param string $data - The encrypted-and-signed message as base64 ASCII
-     *
-     * @return bool|string - The decrypted cleartext or false if signature failed
-     */
-    public function decrypt($data)
-    {
-        $c = base64_decode($data);
-        $cipher = "AES-256-CBC";
-        $ivlen = openssl_cipher_iv_length($cipher);
-        $iv = substr($c, 0, $ivlen);
-        $hmac = substr($c, $ivlen, $sha2len = 32);
-        $ciphertext_raw = substr($c, $ivlen + $sha2len);
-        $cleartext = openssl_decrypt($ciphertext_raw, $cipher, $this->saltedKey, $options = OPENSSL_RAW_DATA, $iv);
-        $calcmac = hash_hmac('sha256', $ciphertext_raw, $this->saltedKey, $as_binary = true);
+	/**
+	 * Check the signature on an encrypted-and-signed message, and if valid
+	 * decrypt the content
+	 *
+	 * @param string $data - The encrypted-and-signed message as base64 ASCII
+	 *
+	 * @return bool|string - The decrypted cleartext or false if signature failed
+	 */
+	public function decrypt($data)
+	{
+		$c = base64_decode($data);
+		$cipher = "AES-256-CBC";
+		$ivlen = openssl_cipher_iv_length($cipher);
+		$iv = substr($c, 0, $ivlen);
+		$hmac = substr($c, $ivlen, $sha2len = 32);
+		$ciphertext_raw = substr($c, $ivlen + $sha2len);
+		$cleartext = openssl_decrypt($ciphertext_raw, $cipher, $this->saltedKey, $options = OPENSSL_RAW_DATA, $iv);
+		$calcmac = hash_hmac('sha256', $ciphertext_raw, $this->saltedKey, $as_binary = true);
 
-        if (hash_equals($hmac, $calcmac)) {
-            return $cleartext;
-        }
+		if (hash_equals($hmac, $calcmac)) {
+			return $cleartext;
+		}
 
-        return false;
-    }
+		return false;
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -64,9 +64,9 @@
         $iv = openssl_random_pseudo_bytes($ivlen);
         $ciphertext_raw = openssl_encrypt($cleartext, $cipher, $this->saltedKey, $options = OPENSSL_RAW_DATA, $iv);
         $hmac = hash_hmac('sha256', $ciphertext_raw, $this->saltedKey, $as_binary = true);
-        $ciphertext = base64_encode($iv . $hmac . $ciphertext_raw);
+        $ciphertext = base64_encode($iv.$hmac.$ciphertext_raw);
 
-        return base64_encode($iv . $hmac . $ciphertext_raw);
+        return base64_encode($iv.$hmac.$ciphertext_raw);
     }
 
     /**

src/Store/CookieStore.php

Indentation +180 added lines, -180 removed lines

@@ -22,184 +22,184 @@
 class CookieStore extends BaseStore
 {
 
-    /**
-     * Maximum length of a cookie value in characters
-     *
-     * @var int
-     * @config
-     */
-    private static $max_length = 1024;
-
-    /**
-     * Encryption service
-     *
-     * @var HybridSessionStore_Crypto
-     */
-    protected $crypto;
-
-    /**
-     * Name of cookie
-     *
-     * @var string
-     */
-    protected $cookie;
-
-    /**
-     * Known unmodified value of this cookie. If the cookie backend has been read into the application,
-     * then the backend is unable to verify the modification state of this value internally within the
-     * system, so this will be left null unless written back.
-     *
-     * If the content exceeds max_length then the backend can also not maintain this cookie, also
-     * setting this variable to null.
-     *
-     * @var string
-     */
-    protected $currentCookieData;
-
-    public function open($save_path, $name)
-    {
-        $this->cookie = $name . '_2';
-
-        // Read the incoming value, then clear the cookie - we might not be able
-        // to do so later if write() is called after headers are sent
-        // This is intended to force a failover to the database store if the
-        // modified session cannot be emitted.
-        $this->currentCookieData = Cookie::get($this->cookie);
-
-        if ($this->currentCookieData) {
-            Cookie::set($this->cookie, '');
-        }
-    }
-
-    public function close()
-    {
-    }
-
-    /**
-     * Get the cryptography store for the specified session
-     *
-     * @param string $session_id
-     * @return HybridSessionStore_Crypto
-     */
-    protected function getCrypto($session_id)
-    {
-        $key = $this->getKey();
-
-        if (!$key) {
-            return null;
-        }
-
-        if (!$this->crypto || $this->crypto->getSalt() != $session_id) {
-            $this->crypto = Injector::inst()->create(CryptoHandler::class, $key, $session_id);
-        }
-
-        return $this->crypto;
-    }
-
-    public function read($session_id)
-    {
-        // Check ability to safely decrypt content
-        if (!$this->currentCookieData
-            || !($crypto = $this->getCrypto($session_id))
-        ) {
-            return;
-        }
-
-        // Decrypt and invalidate old data
-        $cookieData = $crypto->decrypt($this->currentCookieData);
-        $this->currentCookieData = null;
-
-        // Verify expiration
-        if ($cookieData) {
-            $expiry = (int)substr($cookieData, 0, 10);
-            $data = substr($cookieData, 10);
-
-            if ($expiry > $this->getNow()) {
-                return $data;
-            }
-        }
-    }
-
-    /**
-     * Determine if the session could be verifably written to cookie storage
-     *
-     * @return bool
-     */
-    protected function canWrite()
-    {
-        return !headers_sent();
-    }
-
-    public function write($session_id, $session_data)
-    {
-        $canWrite = $this->canWrite();
-        $isExceedingCookieLimit = (strlen($session_data) > static::config()->get('max_length'));
-        $crypto = $this->getCrypto($session_id);
-
-        // Check ability to safely encrypt and write content
-        if (!$canWrite || $isExceedingCookieLimit || !$crypto) {
-            if ($canWrite && $isExceedingCookieLimit) {
-                $params = session_get_cookie_params();
-                // Clear stored cookie value and cookie when length exceeds the set limit
-                $this->currentCookieData = null;
-                Cookie::set(
-                    $this->cookie,
-                    '',
-                    0,
-                    $params['path'],
-                    $params['domain'],
-                    $params['secure'],
-                    $params['httponly']
-                );
-            }
-
-            return false;
-        }
-
-        // Prepare content for write
-        $params = session_get_cookie_params();
-        // Total max lifetime, stored internally
-        $lifetime = $this->getLifetime();
-        $expiry = $this->getNow() + $lifetime;
-
-        // Restore the known good cookie value
-        $this->currentCookieData = $this->crypto->encrypt(
-            sprintf('%010u', $expiry) . $session_data
-        );
-
-        // Respect auto-expire on browser close for the session cookie (in case the cookie lifetime is zero)
-        $cookieLifetime = min((int)$params['lifetime'], $lifetime);
-
-        Cookie::set(
-            $this->cookie,
-            $this->currentCookieData,
-            $cookieLifetime / 86400,
-            $params['path'],
-            $params['domain'],
-            $params['secure'],
-            $params['httponly']
-        );
-
-        return true;
-    }
-
-    public function destroy($session_id)
-    {
-        $this->currentCookieData = null;
-
-        $params = session_get_cookie_params();
-
-        Cookie::force_expiry(
-            $this->cookie,
-            $params['path'],
-            $params['domain'],
-            $params['secure'],
-            $params['httponly']
-        );
-    }
-
-    public function gc($maxlifetime)
-    {
-        // NOP
-    }
+	/**
+	 * Maximum length of a cookie value in characters
+	 *
+	 * @var int
+	 * @config
+	 */
+	private static $max_length = 1024;
+
+	/**
+	 * Encryption service
+	 *
+	 * @var HybridSessionStore_Crypto
+	 */
+	protected $crypto;
+
+	/**
+	 * Name of cookie
+	 *
+	 * @var string
+	 */
+	protected $cookie;
+
+	/**
+	 * Known unmodified value of this cookie. If the cookie backend has been read into the application,
+	 * then the backend is unable to verify the modification state of this value internally within the
+	 * system, so this will be left null unless written back.
+	 *
+	 * If the content exceeds max_length then the backend can also not maintain this cookie, also
+	 * setting this variable to null.
+	 *
+	 * @var string
+	 */
+	protected $currentCookieData;
+
+	public function open($save_path, $name)
+	{
+		$this->cookie = $name . '_2';
+
+		// Read the incoming value, then clear the cookie - we might not be able
+		// to do so later if write() is called after headers are sent
+		// This is intended to force a failover to the database store if the
+		// modified session cannot be emitted.
+		$this->currentCookieData = Cookie::get($this->cookie);
+
+		if ($this->currentCookieData) {
+			Cookie::set($this->cookie, '');
+		}
+	}
+
+	public function close()
+	{
+	}
+
+	/**
+	 * Get the cryptography store for the specified session
+	 *
+	 * @param string $session_id
+	 * @return HybridSessionStore_Crypto
+	 */
+	protected function getCrypto($session_id)
+	{
+		$key = $this->getKey();
+
+		if (!$key) {
+			return null;
+		}
+
+		if (!$this->crypto || $this->crypto->getSalt() != $session_id) {
+			$this->crypto = Injector::inst()->create(CryptoHandler::class, $key, $session_id);
+		}
+
+		return $this->crypto;
+	}
+
+	public function read($session_id)
+	{
+		// Check ability to safely decrypt content
+		if (!$this->currentCookieData
+			|| !($crypto = $this->getCrypto($session_id))
+		) {
+			return;
+		}
+
+		// Decrypt and invalidate old data
+		$cookieData = $crypto->decrypt($this->currentCookieData);
+		$this->currentCookieData = null;
+
+		// Verify expiration
+		if ($cookieData) {
+			$expiry = (int)substr($cookieData, 0, 10);
+			$data = substr($cookieData, 10);
+
+			if ($expiry > $this->getNow()) {
+				return $data;
+			}
+		}
+	}
+
+	/**
+	 * Determine if the session could be verifably written to cookie storage
+	 *
+	 * @return bool
+	 */
+	protected function canWrite()
+	{
+		return !headers_sent();
+	}
+
+	public function write($session_id, $session_data)
+	{
+		$canWrite = $this->canWrite();
+		$isExceedingCookieLimit = (strlen($session_data) > static::config()->get('max_length'));
+		$crypto = $this->getCrypto($session_id);
+
+		// Check ability to safely encrypt and write content
+		if (!$canWrite || $isExceedingCookieLimit || !$crypto) {
+			if ($canWrite && $isExceedingCookieLimit) {
+				$params = session_get_cookie_params();
+				// Clear stored cookie value and cookie when length exceeds the set limit
+				$this->currentCookieData = null;
+				Cookie::set(
+					$this->cookie,
+					'',
+					0,
+					$params['path'],
+					$params['domain'],
+					$params['secure'],
+					$params['httponly']
+				);
+			}
+
+			return false;
+		}
+
+		// Prepare content for write
+		$params = session_get_cookie_params();
+		// Total max lifetime, stored internally
+		$lifetime = $this->getLifetime();
+		$expiry = $this->getNow() + $lifetime;
+
+		// Restore the known good cookie value
+		$this->currentCookieData = $this->crypto->encrypt(
+			sprintf('%010u', $expiry) . $session_data
+		);
+
+		// Respect auto-expire on browser close for the session cookie (in case the cookie lifetime is zero)
+		$cookieLifetime = min((int)$params['lifetime'], $lifetime);
+
+		Cookie::set(
+			$this->cookie,
+			$this->currentCookieData,
+			$cookieLifetime / 86400,
+			$params['path'],
+			$params['domain'],
+			$params['secure'],
+			$params['httponly']
+		);
+
+		return true;
+	}
+
+	public function destroy($session_id)
+	{
+		$this->currentCookieData = null;
+
+		$params = session_get_cookie_params();
+
+		Cookie::force_expiry(
+			$this->cookie,
+			$params['path'],
+			$params['domain'],
+			$params['secure'],
+			$params['httponly']
+		);
+	}
+
+	public function gc($maxlifetime)
+	{
+		// NOP
+	}
 }

Spacing +4 added lines, -4 removed lines

@@ -58,7 +58,7 @@ 
 
     public function open($save_path, $name)
     {
-        $this->cookie = $name . '_2';
+        $this->cookie = $name.'_2';
 
         // Read the incoming value, then clear the cookie - we might not be able
         // to do so later if write() is called after headers are sent
@@ -111,7 +111,7 @@ 
 
         // Verify expiration
         if ($cookieData) {
-            $expiry = (int)substr($cookieData, 0, 10);
+            $expiry = (int) substr($cookieData, 0, 10);
             $data = substr($cookieData, 10);
 
             if ($expiry > $this->getNow()) {
@@ -164,11 +164,11 @@ 
 
         // Restore the known good cookie value
         $this->currentCookieData = $this->crypto->encrypt(
-            sprintf('%010u', $expiry) . $session_data
+            sprintf('%010u', $expiry).$session_data
         );
 
         // Respect auto-expire on browser close for the session cookie (in case the cookie lifetime is zero)
-        $cookieLifetime = min((int)$params['lifetime'], $lifetime);
+        $cookieLifetime = min((int) $params['lifetime'], $lifetime);
 
         Cookie::set(
             $this->cookie,