migrate therinaldos.com data

wedding-pics/lib/private/Session/CryptoSessionData.php

@@ -0,0 +1,253 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Victor Dubiniuk <dubiniuk@owncloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Session;
+
+use OCP\ISession;
+use OCP\Security\ICrypto;
+use OCP\Session\Exceptions\SessionNotAvailableException;
+use function json_decode;
+use function OCP\Log\logger;
+
+/**
+ * Class CryptoSessionData
+ *
+ * @package OC\Session
+ */
+class CryptoSessionData implements \ArrayAccess, ISession {
+	/** @var ISession */
+	protected $session;
+	/** @var \OCP\Security\ICrypto */
+	protected $crypto;
+	/** @var string */
+	protected $passphrase;
+	/** @var array */
+	protected $sessionValues;
+	/** @var bool */
+	protected $isModified = false;
+	public const encryptedSessionName = 'encrypted_session_data';
+
+	/**
+	 * @param ISession $session
+	 * @param ICrypto $crypto
+	 * @param string $passphrase
+	 */
+	public function __construct(ISession $session,
+		ICrypto $crypto,
+		string $passphrase) {
+		$this->crypto = $crypto;
+		$this->session = $session;
+		$this->passphrase = $passphrase;
+		$this->initializeSession();
+	}
+
+	/**
+	 * Close session if class gets destructed
+	 */
+	public function __destruct() {
+		try {
+			$this->close();
+		} catch (SessionNotAvailableException $e) {
+			// This exception can occur if session is already closed
+			// So it is safe to ignore it and let the garbage collector to proceed
+		}
+	}
+
+	protected function initializeSession() {
+		$encryptedSessionData = $this->session->get(self::encryptedSessionName) ?: '';
+		if ($encryptedSessionData === '') {
+			// Nothing to decrypt
+			$this->sessionValues = [];
+		} else {
+			try {
+				$this->sessionValues = json_decode(
+					$this->crypto->decrypt($encryptedSessionData, $this->passphrase),
+					true,
+					512,
+					JSON_THROW_ON_ERROR,
+				);
+			} catch (\Exception $e) {
+				logger('core')->critical('Could not decrypt or decode encrypted session data', [
+					'exception' => $e,
+				]);
+				$this->sessionValues = [];
+				$this->regenerateId(true, false);
+			}
+		}
+	}
+
+	/**
+	 * Set a value in the session
+	 *
+	 * @param string $key
+	 * @param mixed $value
+	 */
+	public function set(string $key, $value) {
+		if ($this->get($key) === $value) {
+			// Do not write the session if the value hasn't changed to avoid reopening
+			return;
+		}
+
+		$reopened = $this->reopen();
+		$this->sessionValues[$key] = $value;
+		$this->isModified = true;
+		if ($reopened) {
+			$this->close();
+		}
+	}
+
+	/**
+	 * Get a value from the session
+	 *
+	 * @param string $key
+	 * @return string|null Either the value or null
+	 */
+	public function get(string $key) {
+		if (isset($this->sessionValues[$key])) {
+			return $this->sessionValues[$key];
+		}
+
+		return null;
+	}
+
+	/**
+	 * Check if a named key exists in the session
+	 *
+	 * @param string $key
+	 * @return bool
+	 */
+	public function exists(string $key): bool {
+		return isset($this->sessionValues[$key]);
+	}
+
+	/**
+	 * Remove a $key/$value pair from the session
+	 *
+	 * @param string $key
+	 */
+	public function remove(string $key) {
+		$reopened = $this->reopen();
+		$this->isModified = true;
+		unset($this->sessionValues[$key]);
+		if ($reopened) {
+			$this->close();
+		}
+	}
+
+	/**
+	 * Reset and recreate the session
+	 */
+	public function clear() {
+		$reopened = $this->reopen();
+		$requesttoken = $this->get('requesttoken');
+		$this->sessionValues = [];
+		if ($requesttoken !== null) {
+			$this->set('requesttoken', $requesttoken);
+		}
+		$this->isModified = true;
+		$this->session->clear();
+		if ($reopened) {
+			$this->close();
+		}
+	}
+
+	public function reopen(): bool {
+		$reopened = $this->session->reopen();
+		if ($reopened) {
+			$this->initializeSession();
+		}
+		return $reopened;
+	}
+
+	/**
+	 * Wrapper around session_regenerate_id
+	 *
+	 * @param bool $deleteOldSession Whether to delete the old associated session file or not.
+	 * @param bool $updateToken Wheater to update the associated auth token
+	 * @return void
+	 */
+	public function regenerateId(bool $deleteOldSession = true, bool $updateToken = false) {
+		$this->session->regenerateId($deleteOldSession, $updateToken);
+	}
+
+	/**
+	 * Wrapper around session_id
+	 *
+	 * @return string
+	 * @throws SessionNotAvailableException
+	 * @since 9.1.0
+	 */
+	public function getId(): string {
+		return $this->session->getId();
+	}
+
+	/**
+	 * Close the session and release the lock, also writes all changed data in batch
+	 */
+	public function close() {
+		if ($this->isModified) {
+			$encryptedValue = $this->crypto->encrypt(json_encode($this->sessionValues), $this->passphrase);
+			$this->session->set(self::encryptedSessionName, $encryptedValue);
+			$this->isModified = false;
+		}
+		$this->session->close();
+	}
+
+	/**
+	 * @param mixed $offset
+	 * @return bool
+	 */
+	public function offsetExists($offset): bool {
+		return $this->exists($offset);
+	}
+
+	/**
+	 * @param mixed $offset
+	 * @return mixed
+	 */
+	#[\ReturnTypeWillChange]
+	public function offsetGet($offset) {
+		return $this->get($offset);
+	}
+
+	/**
+	 * @param mixed $offset
+	 * @param mixed $value
+	 */
+	public function offsetSet($offset, $value): void {
+		$this->set($offset, $value);
+	}
+
+	/**
+	 * @param mixed $offset
+	 */
+	public function offsetUnset($offset): void {
+		$this->remove($offset);
+	}
+}

wedding-pics/lib/private/Session/CryptoWrapper.php

@@ -0,0 +1,117 @@
+<?php
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Phil Davis <phil.davis@inf.org>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Session;
+
+use OCP\IConfig;
+use OCP\IRequest;
+use OCP\ISession;
+use OCP\Security\ICrypto;
+use OCP\Security\ISecureRandom;
+
+/**
+ * Class CryptoWrapper provides some rough basic level of additional security by
+ * storing the session data in an encrypted form.
+ *
+ * The content of the session is encrypted using another cookie sent by the browser.
+ * One should note that an adversary with access to the source code or the system
+ * memory is still able to read the original session ID from the users' request.
+ * This thus can not be considered a strong security measure one should consider
+ * it as an additional small security obfuscation layer to comply with compliance
+ * guidelines.
+ *
+ * TODO: Remove this in a future release with an approach such as
+ * https://github.com/owncloud/core/pull/17866
+ *
+ * @package OC\Session
+ */
+class CryptoWrapper {
+	public const COOKIE_NAME = 'oc_sessionPassphrase';
+
+	/** @var IConfig */
+	protected $config;
+	/** @var ISession */
+	protected $session;
+	/** @var ICrypto */
+	protected $crypto;
+	/** @var ISecureRandom */
+	protected $random;
+	/** @var string */
+	protected $passphrase;
+
+	/**
+	 * @param IConfig $config
+	 * @param ICrypto $crypto
+	 * @param ISecureRandom $random
+	 * @param IRequest $request
+	 */
+	public function __construct(IConfig $config,
+		ICrypto $crypto,
+		ISecureRandom $random,
+		IRequest $request) {
+		$this->crypto = $crypto;
+		$this->config = $config;
+		$this->random = $random;
+
+		if (!is_null($request->getCookie(self::COOKIE_NAME))) {
+			$this->passphrase = $request->getCookie(self::COOKIE_NAME);
+		} else {
+			$this->passphrase = $this->random->generate(128);
+			$secureCookie = $request->getServerProtocol() === 'https';
+			// FIXME: Required for CI
+			if (!defined('PHPUNIT_RUN')) {
+				$webRoot = \OC::$WEBROOT;
+				if ($webRoot === '') {
+					$webRoot = '/';
+				}
+
+				setcookie(
+					self::COOKIE_NAME,
+					$this->passphrase,
+					[
+						'expires' => 0,
+						'path' => $webRoot,
+						'domain' => '',
+						'secure' => $secureCookie,
+						'httponly' => true,
+						'samesite' => 'Lax',
+					]
+				);
+			}
+		}
+	}
+
+	/**
+	 * @param ISession $session
+	 * @return ISession
+	 */
+	public function wrapSession(ISession $session) {
+		if (!($session instanceof CryptoSessionData)) {
+			return new CryptoSessionData($session, $this->crypto, $this->passphrase);
+		}
+
+		return $session;
+	}
+}

wedding-pics/lib/private/Session/Internal.php

@@ -0,0 +1,227 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Arthur Schiwon <blizzz@arthur-schiwon.de>
+ * @author cetra3 <peter@parashift.com.au>
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author MartB <mart.b@outlook.de>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ * @author Victor Dubiniuk <dubiniuk@owncloud.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Session;
+
+use OC\Authentication\Token\IProvider;
+use OCP\Authentication\Exceptions\InvalidTokenException;
+use OCP\Session\Exceptions\SessionNotAvailableException;
+
+/**
+ * Class Internal
+ *
+ * wrap php's internal session handling into the Session interface
+ *
+ * @package OC\Session
+ */
+class Internal extends Session {
+	/**
+	 * @param string $name
+	 * @throws \Exception
+	 */
+	public function __construct(string $name) {
+		set_error_handler([$this, 'trapError']);
+		$this->invoke('session_name', [$name]);
+		try {
+			$this->startSession();
+		} catch (\Exception $e) {
+			setcookie($this->invoke('session_name'), '', -1, \OC::$WEBROOT ?: '/');
+		}
+		restore_error_handler();
+		if (!isset($_SESSION)) {
+			throw new \Exception('Failed to start session');
+		}
+	}
+
+	/**
+	 * @param string $key
+	 * @param integer $value
+	 */
+	public function set(string $key, $value) {
+		$reopened = $this->reopen();
+		$_SESSION[$key] = $value;
+		if ($reopened) {
+			$this->close();
+		}
+	}
+
+	/**
+	 * @param string $key
+	 * @return mixed
+	 */
+	public function get(string $key) {
+		if (!$this->exists($key)) {
+			return null;
+		}
+		return $_SESSION[$key];
+	}
+
+	/**
+	 * @param string $key
+	 * @return bool
+	 */
+	public function exists(string $key): bool {
+		return isset($_SESSION[$key]);
+	}
+
+	/**
+	 * @param string $key
+	 */
+	public function remove(string $key) {
+		if (isset($_SESSION[$key])) {
+			unset($_SESSION[$key]);
+		}
+	}
+
+	public function clear() {
+		$this->reopen();
+		$this->invoke('session_unset');
+		$this->regenerateId();
+		$this->invoke('session_write_close');
+		$this->startSession(true);
+		$_SESSION = [];
+	}
+
+	public function close() {
+		$this->invoke('session_write_close');
+		parent::close();
+	}
+
+	/**
+	 * Wrapper around session_regenerate_id
+	 *
+	 * @param bool $deleteOldSession Whether to delete the old associated session file or not.
+	 * @param bool $updateToken Wheater to update the associated auth token
+	 * @return void
+	 */
+	public function regenerateId(bool $deleteOldSession = true, bool $updateToken = false) {
+		$this->reopen();
+		$oldId = null;
+
+		if ($updateToken) {
+			// Get the old id to update the token
+			try {
+				$oldId = $this->getId();
+			} catch (SessionNotAvailableException $e) {
+				// We can't update a token if there is no previous id
+				$updateToken = false;
+			}
+		}
+
+		try {
+			@session_regenerate_id($deleteOldSession);
+		} catch (\Error $e) {
+			$this->trapError($e->getCode(), $e->getMessage());
+		}
+
+		if ($updateToken) {
+			// Get the new id to update the token
+			$newId = $this->getId();
+
+			/** @var IProvider $tokenProvider */
+			$tokenProvider = \OCP\Server::get(IProvider::class);
+
+			try {
+				$tokenProvider->renewSessionToken($oldId, $newId);
+			} catch (InvalidTokenException $e) {
+				// Just ignore
+			}
+		}
+	}
+
+	/**
+	 * Wrapper around session_id
+	 *
+	 * @return string
+	 * @throws SessionNotAvailableException
+	 * @since 9.1.0
+	 */
+	public function getId(): string {
+		$id = $this->invoke('session_id', [], true);
+		if ($id === '') {
+			throw new SessionNotAvailableException();
+		}
+		return $id;
+	}
+
+	/**
+	 * @throws \Exception
+	 */
+	public function reopen(): bool {
+		if ($this->sessionClosed) {
+			$this->startSession(false, false);
+			$this->sessionClosed = false;
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * @param int $errorNumber
+	 * @param string $errorString
+	 * @throws \ErrorException
+	 */
+	public function trapError(int $errorNumber, string $errorString) {
+		if ($errorNumber & E_ERROR) {
+			throw new \ErrorException($errorString);
+		}
+	}
+
+	/**
+	 * @param string $functionName the full session_* function name
+	 * @param array $parameters
+	 * @param bool $silence whether to suppress warnings
+	 * @throws \ErrorException via trapError
+	 * @return mixed
+	 */
+	private function invoke(string $functionName, array $parameters = [], bool $silence = false) {
+		try {
+			if ($silence) {
+				return @call_user_func_array($functionName, $parameters);
+			} else {
+				return call_user_func_array($functionName, $parameters);
+			}
+		} catch (\Error $e) {
+			$this->trapError($e->getCode(), $e->getMessage());
+		}
+	}
+
+	private function startSession(bool $silence = false, bool $readAndClose = true) {
+		$sessionParams = ['cookie_samesite' => 'Lax'];
+		if (\OC::hasSessionRelaxedExpiry()) {
+			$sessionParams['read_and_close'] = $readAndClose;
+		}
+		$this->invoke('session_start', [$sessionParams], $silence);
+	}
+}

wedding-pics/lib/private/Session/Memory.php

@@ -0,0 +1,115 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Jörn Friedrich Dreyer <jfd@butonic.de>
+ * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Session;
+
+use OCP\Session\Exceptions\SessionNotAvailableException;
+
+/**
+ * Class Internal
+ *
+ * store session data in an in-memory array, not persistent
+ *
+ * @package OC\Session
+ */
+class Memory extends Session {
+	protected $data;
+
+	public function __construct(string $name) {
+		//no need to use $name since all data is already scoped to this instance
+		$this->data = [];
+	}
+
+	/**
+	 * @param string $key
+	 * @param integer $value
+	 */
+	public function set(string $key, $value) {
+		$this->data[$key] = $value;
+	}
+
+	/**
+	 * @param string $key
+	 * @return mixed
+	 */
+	public function get(string $key) {
+		if (!$this->exists($key)) {
+			return null;
+		}
+		return $this->data[$key];
+	}
+
+	/**
+	 * @param string $key
+	 * @return bool
+	 */
+	public function exists(string $key): bool {
+		return isset($this->data[$key]);
+	}
+
+	/**
+	 * @param string $key
+	 */
+	public function remove(string $key) {
+		unset($this->data[$key]);
+	}
+
+	public function clear() {
+		$this->data = [];
+	}
+
+	/**
+	 * Stub since the session ID does not need to get regenerated for the cache
+	 *
+	 * @param bool $deleteOldSession
+	 */
+	public function regenerateId(bool $deleteOldSession = true, bool $updateToken = false) {
+	}
+
+	/**
+	 * Wrapper around session_id
+	 *
+	 * @return string
+	 * @throws SessionNotAvailableException
+	 * @since 9.1.0
+	 */
+	public function getId(): string {
+		throw new SessionNotAvailableException('Memory session does not have an ID');
+	}
+
+	/**
+	 * Helper function for PHPUnit execution - don't use in non-test code
+	 */
+	public function reopen(): bool {
+		$reopened = $this->sessionClosed;
+		$this->sessionClosed = false;
+		return $reopened;
+	}
+}

wedding-pics/lib/private/Session/Session.php

@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Robin Appelman <robin@icewind.nl>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ * @author Thomas Müller <thomas.mueller@tmit.eu>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Session;
+
+use OCP\ISession;
+
+abstract class Session implements \ArrayAccess, ISession {
+	/**
+	 * @var bool
+	 */
+	protected $sessionClosed = false;
+
+	/**
+	 * $name serves as a namespace for the session keys
+	 *
+	 * @param string $name
+	 */
+	abstract public function __construct(string $name);
+
+	/**
+	 * @param mixed $offset
+	 * @return bool
+	 */
+	public function offsetExists($offset): bool {
+		return $this->exists($offset);
+	}
+
+	/**
+	 * @param mixed $offset
+	 * @return mixed
+	 */
+	#[\ReturnTypeWillChange]
+	public function offsetGet($offset) {
+		return $this->get($offset);
+	}
+
+	/**
+	 * @param mixed $offset
+	 * @param mixed $value
+	 */
+	public function offsetSet($offset, $value): void {
+		$this->set($offset, $value);
+	}
+
+	/**
+	 * @param mixed $offset
+	 */
+	public function offsetUnset($offset): void {
+		$this->remove($offset);
+	}
+
+	/**
+	 * Close the session and release the lock
+	 */
+	public function close() {
+		$this->sessionClosed = true;
+	}
+}