nextcloud / server

apps/encryption/lib/Controller/SettingsController.php

Indentation +124 added lines, -124 removed lines

@@ -38,129 +38,129 @@
 
 class SettingsController extends Controller {
 
-	/** @var IL10N */
-	private $l;
-
-	/** @var IUserManager */
-	private $userManager;
-
-	/** @var IUserSession */
-	private $userSession;
-
-	/** @var KeyManager */
-	private $keyManager;
-
-	/** @var Crypt */
-	private $crypt;
-
-	/** @var Session */
-	private $session;
-
-	/** @var ISession  */
-	private $ocSession;
-
-	/** @var  Util */
-	private $util;
-
-	/**
-	 * @param string $AppName
-	 * @param IRequest $request
-	 * @param IL10N $l10n
-	 * @param IUserManager $userManager
-	 * @param IUserSession $userSession
-	 * @param KeyManager $keyManager
-	 * @param Crypt $crypt
-	 * @param Session $session
-	 * @param ISession $ocSession
-	 * @param Util $util
-	 */
-	public function __construct($AppName,
-								IRequest $request,
-								IL10N $l10n,
-								IUserManager $userManager,
-								IUserSession $userSession,
-								KeyManager $keyManager,
-								Crypt $crypt,
-								Session $session,
-								ISession $ocSession,
-								Util $util
+    /** @var IL10N */
+    private $l;
+
+    /** @var IUserManager */
+    private $userManager;
+
+    /** @var IUserSession */
+    private $userSession;
+
+    /** @var KeyManager */
+    private $keyManager;
+
+    /** @var Crypt */
+    private $crypt;
+
+    /** @var Session */
+    private $session;
+
+    /** @var ISession  */
+    private $ocSession;
+
+    /** @var  Util */
+    private $util;
+
+    /**
+     * @param string $AppName
+     * @param IRequest $request
+     * @param IL10N $l10n
+     * @param IUserManager $userManager
+     * @param IUserSession $userSession
+     * @param KeyManager $keyManager
+     * @param Crypt $crypt
+     * @param Session $session
+     * @param ISession $ocSession
+     * @param Util $util
+     */
+    public function __construct($AppName,
+                                IRequest $request,
+                                IL10N $l10n,
+                                IUserManager $userManager,
+                                IUserSession $userSession,
+                                KeyManager $keyManager,
+                                Crypt $crypt,
+                                Session $session,
+                                ISession $ocSession,
+                                Util $util
 ) {
-		parent::__construct($AppName, $request);
-		$this->l = $l10n;
-		$this->userSession = $userSession;
-		$this->userManager = $userManager;
-		$this->keyManager = $keyManager;
-		$this->crypt = $crypt;
-		$this->session = $session;
-		$this->ocSession = $ocSession;
-		$this->util = $util;
-	}
-
-
-	/**
-	 * @NoAdminRequired
-	 * @UseSession
-	 *
-	 * @param string $oldPassword
-	 * @param string $newPassword
-	 * @return DataResponse
-	 */
-	public function updatePrivateKeyPassword($oldPassword, $newPassword) {
-		$result = false;
-		$uid = $this->userSession->getUser()->getUID();
-		$errorMessage = $this->l->t('Could not update the private key password.');
-
-		//check if password is correct
-		$passwordCorrect = $this->userManager->checkPassword($uid, $newPassword);
-		if ($passwordCorrect === false) {
-			// if check with uid fails we need to check the password with the login name
-			// e.g. in the ldap case. For local user we need to check the password with
-			// the uid because in this case the login name is case insensitive
-			$loginName = $this->ocSession->get('loginname');
-			$passwordCorrect = $this->userManager->checkPassword($loginName, $newPassword);
-		}
-
-		if ($passwordCorrect !== false) {
-			$encryptedKey = $this->keyManager->getPrivateKey($uid);
-			$decryptedKey = $this->crypt->decryptPrivateKey($encryptedKey, $oldPassword, $uid);
-
-			if ($decryptedKey) {
-				$encryptedKey = $this->crypt->encryptPrivateKey($decryptedKey, $newPassword, $uid);
-				$header = $this->crypt->generateHeader();
-				if ($encryptedKey) {
-					$this->keyManager->setPrivateKey($uid, $header . $encryptedKey);
-					$this->session->setPrivateKey($decryptedKey);
-					$result = true;
-				}
-			} else {
-				$errorMessage = $this->l->t('The old password was not correct, please try again.');
-			}
-		} else {
-			$errorMessage = $this->l->t('The current log-in password was not correct, please try again.');
-		}
-
-		if ($result === true) {
-			$this->session->setStatus(Session::INIT_SUCCESSFUL);
-			return new DataResponse(
-				['message' => (string) $this->l->t('Private key password successfully updated.')]
-			);
-		} else {
-			return new DataResponse(
-				['message' => (string) $errorMessage],
-				Http::STATUS_BAD_REQUEST
-			);
-		}
-
-	}
-
-	/**
-	 * @UseSession
-	 *
-	 * @param bool $encryptHomeStorage
-	 * @return DataResponse
-	 */
-	public function setEncryptHomeStorage($encryptHomeStorage) {
-		$this->util->setEncryptHomeStorage($encryptHomeStorage);
-		return new DataResponse();
-	}
+        parent::__construct($AppName, $request);
+        $this->l = $l10n;
+        $this->userSession = $userSession;
+        $this->userManager = $userManager;
+        $this->keyManager = $keyManager;
+        $this->crypt = $crypt;
+        $this->session = $session;
+        $this->ocSession = $ocSession;
+        $this->util = $util;
+    }
+
+
+    /**
+     * @NoAdminRequired
+     * @UseSession
+     *
+     * @param string $oldPassword
+     * @param string $newPassword
+     * @return DataResponse
+     */
+    public function updatePrivateKeyPassword($oldPassword, $newPassword) {
+        $result = false;
+        $uid = $this->userSession->getUser()->getUID();
+        $errorMessage = $this->l->t('Could not update the private key password.');
+
+        //check if password is correct
+        $passwordCorrect = $this->userManager->checkPassword($uid, $newPassword);
+        if ($passwordCorrect === false) {
+            // if check with uid fails we need to check the password with the login name
+            // e.g. in the ldap case. For local user we need to check the password with
+            // the uid because in this case the login name is case insensitive
+            $loginName = $this->ocSession->get('loginname');
+            $passwordCorrect = $this->userManager->checkPassword($loginName, $newPassword);
+        }
+
+        if ($passwordCorrect !== false) {
+            $encryptedKey = $this->keyManager->getPrivateKey($uid);
+            $decryptedKey = $this->crypt->decryptPrivateKey($encryptedKey, $oldPassword, $uid);
+
+            if ($decryptedKey) {
+                $encryptedKey = $this->crypt->encryptPrivateKey($decryptedKey, $newPassword, $uid);
+                $header = $this->crypt->generateHeader();
+                if ($encryptedKey) {
+                    $this->keyManager->setPrivateKey($uid, $header . $encryptedKey);
+                    $this->session->setPrivateKey($decryptedKey);
+                    $result = true;
+                }
+            } else {
+                $errorMessage = $this->l->t('The old password was not correct, please try again.');
+            }
+        } else {
+            $errorMessage = $this->l->t('The current log-in password was not correct, please try again.');
+        }
+
+        if ($result === true) {
+            $this->session->setStatus(Session::INIT_SUCCESSFUL);
+            return new DataResponse(
+                ['message' => (string) $this->l->t('Private key password successfully updated.')]
+            );
+        } else {
+            return new DataResponse(
+                ['message' => (string) $errorMessage],
+                Http::STATUS_BAD_REQUEST
+            );
+        }
+
+    }
+
+    /**
+     * @UseSession
+     *
+     * @param bool $encryptHomeStorage
+     * @return DataResponse
+     */
+    public function setEncryptHomeStorage($encryptHomeStorage) {
+        $this->util->setEncryptHomeStorage($encryptHomeStorage);
+        return new DataResponse();
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -128,7 +128,7 @@
 				$encryptedKey = $this->crypt->encryptPrivateKey($decryptedKey, $newPassword, $uid);
 				$header = $this->crypt->generateHeader();
 				if ($encryptedKey) {
-					$this->keyManager->setPrivateKey($uid, $header . $encryptedKey);
+					$this->keyManager->setPrivateKey($uid, $header.$encryptedKey);
 					$this->session->setPrivateKey($decryptedKey);
 					$result = true;
 				}

apps/encryption/lib/Controller/RecoveryController.php

Spacing +18 added lines, -18 removed lines

@@ -74,36 +74,36 @@ 
 	public function adminRecovery($recoveryPassword, $confirmPassword, $adminEnableRecovery) {
 		// Check if both passwords are the same
 		if (empty($recoveryPassword)) {
-			$errorMessage = (string)$this->l->t('Missing recovery key password');
+			$errorMessage = (string) $this->l->t('Missing recovery key password');
 			return new DataResponse(['data' => ['message' => $errorMessage]],
 				Http::STATUS_BAD_REQUEST);
 		}
 
 		if (empty($confirmPassword)) {
-			$errorMessage = (string)$this->l->t('Please repeat the recovery key password');
+			$errorMessage = (string) $this->l->t('Please repeat the recovery key password');
 			return new DataResponse(['data' => ['message' => $errorMessage]],
 				Http::STATUS_BAD_REQUEST);
 		}
 
 		if ($recoveryPassword !== $confirmPassword) {
-			$errorMessage = (string)$this->l->t('Repeated recovery key password does not match the provided recovery key password');
+			$errorMessage = (string) $this->l->t('Repeated recovery key password does not match the provided recovery key password');
 			return new DataResponse(['data' => ['message' => $errorMessage]],
 				Http::STATUS_BAD_REQUEST);
 		}
 
 		if (isset($adminEnableRecovery) && $adminEnableRecovery === '1') {
 			if ($this->recovery->enableAdminRecovery($recoveryPassword)) {
-				return new DataResponse(['data' => ['message' => (string)$this->l->t('Recovery key successfully enabled')]]);
+				return new DataResponse(['data' => ['message' => (string) $this->l->t('Recovery key successfully enabled')]]);
 			}
-			return new DataResponse(['data' => ['message' => (string)$this->l->t('Could not enable recovery key. Please check your recovery key password!')]], Http::STATUS_BAD_REQUEST);
+			return new DataResponse(['data' => ['message' => (string) $this->l->t('Could not enable recovery key. Please check your recovery key password!')]], Http::STATUS_BAD_REQUEST);
 		} elseif (isset($adminEnableRecovery) && $adminEnableRecovery === '0') {
 			if ($this->recovery->disableAdminRecovery($recoveryPassword)) {
-				return new DataResponse(['data' => ['message' => (string)$this->l->t('Recovery key successfully disabled')]]);
+				return new DataResponse(['data' => ['message' => (string) $this->l->t('Recovery key successfully disabled')]]);
 			}
-			return new DataResponse(['data' => ['message' => (string)$this->l->t('Could not disable recovery key. Please check your recovery key password!')]], Http::STATUS_BAD_REQUEST);
+			return new DataResponse(['data' => ['message' => (string) $this->l->t('Could not disable recovery key. Please check your recovery key password!')]], Http::STATUS_BAD_REQUEST);
 		}
 		// this response should never be sent but just in case.
-		return new DataResponse(['data' => ['message' => (string)$this->l->t('Missing parameters')]], Http::STATUS_BAD_REQUEST);
+		return new DataResponse(['data' => ['message' => (string) $this->l->t('Missing parameters')]], Http::STATUS_BAD_REQUEST);
 	}
 
 	/**
@@ -115,22 +115,22 @@ 
 	public function changeRecoveryPassword($newPassword, $oldPassword, $confirmPassword) {
 		//check if both passwords are the same
 		if (empty($oldPassword)) {
-			$errorMessage = (string)$this->l->t('Please provide the old recovery password');
+			$errorMessage = (string) $this->l->t('Please provide the old recovery password');
 			return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
 		}
 
 		if (empty($newPassword)) {
-			$errorMessage = (string)$this->l->t('Please provide a new recovery password');
-			return new DataResponse (['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
+			$errorMessage = (string) $this->l->t('Please provide a new recovery password');
+			return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
 		}
 
 		if (empty($confirmPassword)) {
-			$errorMessage = (string)$this->l->t('Please repeat the new recovery password');
+			$errorMessage = (string) $this->l->t('Please repeat the new recovery password');
 			return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
 		}
 
 		if ($newPassword !== $confirmPassword) {
-			$errorMessage = (string)$this->l->t('Repeated recovery key password does not match the provided recovery key password');
+			$errorMessage = (string) $this->l->t('Repeated recovery key password does not match the provided recovery key password');
 			return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
 		}
 
@@ -141,14 +141,14 @@ 
 			return new DataResponse(
 				[
 					'data' => [
-						'message' => (string)$this->l->t('Password successfully changed.')]
+						'message' => (string) $this->l->t('Password successfully changed.')]
 				]
 			);
 		}
 		return new DataResponse(
 			[
 				'data' => [
-					'message' => (string)$this->l->t('Could not change the password. Maybe the old password was not correct.')
+					'message' => (string) $this->l->t('Could not change the password. Maybe the old password was not correct.')
 				]
 			], Http::STATUS_BAD_REQUEST);
 	}
@@ -169,14 +169,14 @@ 
 					return new DataResponse(
 						[
 							'data' => [
-								'message' => (string)$this->l->t('Recovery Key disabled')]
+								'message' => (string) $this->l->t('Recovery Key disabled')]
 						]
 					);
 				}
 				return new DataResponse(
 					[
 						'data' => [
-							'message' => (string)$this->l->t('Recovery Key enabled')]
+							'message' => (string) $this->l->t('Recovery Key enabled')]
 					]
 				);
 			}
@@ -185,7 +185,7 @@ 
 		return new DataResponse(
 			[
 				'data' => [
-					'message' => (string)$this->l->t('Could not enable the recovery key, please try again or contact your administrator')
+					'message' => (string) $this->l->t('Could not enable the recovery key, please try again or contact your administrator')
 				]
 			], Http::STATUS_BAD_REQUEST);
 	}

Indentation +155 added lines, -155 removed lines

@@ -34,160 +34,160 @@
 use OCP\IRequest;
 
 class RecoveryController extends Controller {
-	/**
-	 * @var IConfig
-	 */
-	private $config;
-	/**
-	 * @var IL10N
-	 */
-	private $l;
-	/**
-	 * @var Recovery
-	 */
-	private $recovery;
-
-	/**
-	 * @param string $AppName
-	 * @param IRequest $request
-	 * @param IConfig $config
-	 * @param IL10N $l10n
-	 * @param Recovery $recovery
-	 */
-	public function __construct($AppName,
-								IRequest $request,
-								IConfig $config,
-								IL10N $l10n,
-								Recovery $recovery) {
-		parent::__construct($AppName, $request);
-		$this->config = $config;
-		$this->l = $l10n;
-		$this->recovery = $recovery;
-	}
-
-	/**
-	 * @param string $recoveryPassword
-	 * @param string $confirmPassword
-	 * @param string $adminEnableRecovery
-	 * @return DataResponse
-	 */
-	public function adminRecovery($recoveryPassword, $confirmPassword, $adminEnableRecovery) {
-		// Check if both passwords are the same
-		if (empty($recoveryPassword)) {
-			$errorMessage = (string)$this->l->t('Missing recovery key password');
-			return new DataResponse(['data' => ['message' => $errorMessage]],
-				Http::STATUS_BAD_REQUEST);
-		}
-
-		if (empty($confirmPassword)) {
-			$errorMessage = (string)$this->l->t('Please repeat the recovery key password');
-			return new DataResponse(['data' => ['message' => $errorMessage]],
-				Http::STATUS_BAD_REQUEST);
-		}
-
-		if ($recoveryPassword !== $confirmPassword) {
-			$errorMessage = (string)$this->l->t('Repeated recovery key password does not match the provided recovery key password');
-			return new DataResponse(['data' => ['message' => $errorMessage]],
-				Http::STATUS_BAD_REQUEST);
-		}
-
-		if (isset($adminEnableRecovery) && $adminEnableRecovery === '1') {
-			if ($this->recovery->enableAdminRecovery($recoveryPassword)) {
-				return new DataResponse(['data' => ['message' => (string)$this->l->t('Recovery key successfully enabled')]]);
-			}
-			return new DataResponse(['data' => ['message' => (string)$this->l->t('Could not enable recovery key. Please check your recovery key password!')]], Http::STATUS_BAD_REQUEST);
-		} elseif (isset($adminEnableRecovery) && $adminEnableRecovery === '0') {
-			if ($this->recovery->disableAdminRecovery($recoveryPassword)) {
-				return new DataResponse(['data' => ['message' => (string)$this->l->t('Recovery key successfully disabled')]]);
-			}
-			return new DataResponse(['data' => ['message' => (string)$this->l->t('Could not disable recovery key. Please check your recovery key password!')]], Http::STATUS_BAD_REQUEST);
-		}
-		// this response should never be sent but just in case.
-		return new DataResponse(['data' => ['message' => (string)$this->l->t('Missing parameters')]], Http::STATUS_BAD_REQUEST);
-	}
-
-	/**
-	 * @param string $newPassword
-	 * @param string $oldPassword
-	 * @param string $confirmPassword
-	 * @return DataResponse
-	 */
-	public function changeRecoveryPassword($newPassword, $oldPassword, $confirmPassword) {
-		//check if both passwords are the same
-		if (empty($oldPassword)) {
-			$errorMessage = (string)$this->l->t('Please provide the old recovery password');
-			return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
-		}
-
-		if (empty($newPassword)) {
-			$errorMessage = (string)$this->l->t('Please provide a new recovery password');
-			return new DataResponse (['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
-		}
-
-		if (empty($confirmPassword)) {
-			$errorMessage = (string)$this->l->t('Please repeat the new recovery password');
-			return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
-		}
-
-		if ($newPassword !== $confirmPassword) {
-			$errorMessage = (string)$this->l->t('Repeated recovery key password does not match the provided recovery key password');
-			return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
-		}
-
-		$result = $this->recovery->changeRecoveryKeyPassword($newPassword,
-			$oldPassword);
-
-		if ($result) {
-			return new DataResponse(
-				[
-					'data' => [
-						'message' => (string)$this->l->t('Password successfully changed.')]
-				]
-			);
-		}
-		return new DataResponse(
-			[
-				'data' => [
-					'message' => (string)$this->l->t('Could not change the password. Maybe the old password was not correct.')
-				]
-			], Http::STATUS_BAD_REQUEST);
-	}
-
-	/**
-	 * @NoAdminRequired
-	 *
-	 * @param string $userEnableRecovery
-	 * @return DataResponse
-	 */
-	public function userSetRecovery($userEnableRecovery) {
-		if ($userEnableRecovery === '0' || $userEnableRecovery === '1') {
-
-			$result = $this->recovery->setRecoveryForUser($userEnableRecovery);
-
-			if ($result) {
-				if ($userEnableRecovery === '0') {
-					return new DataResponse(
-						[
-							'data' => [
-								'message' => (string)$this->l->t('Recovery Key disabled')]
-						]
-					);
-				}
-				return new DataResponse(
-					[
-						'data' => [
-							'message' => (string)$this->l->t('Recovery Key enabled')]
-					]
-				);
-			}
-
-		}
-		return new DataResponse(
-			[
-				'data' => [
-					'message' => (string)$this->l->t('Could not enable the recovery key, please try again or contact your administrator')
-				]
-			], Http::STATUS_BAD_REQUEST);
-	}
+    /**
+     * @var IConfig
+     */
+    private $config;
+    /**
+     * @var IL10N
+     */
+    private $l;
+    /**
+     * @var Recovery
+     */
+    private $recovery;
+
+    /**
+     * @param string $AppName
+     * @param IRequest $request
+     * @param IConfig $config
+     * @param IL10N $l10n
+     * @param Recovery $recovery
+     */
+    public function __construct($AppName,
+                                IRequest $request,
+                                IConfig $config,
+                                IL10N $l10n,
+                                Recovery $recovery) {
+        parent::__construct($AppName, $request);
+        $this->config = $config;
+        $this->l = $l10n;
+        $this->recovery = $recovery;
+    }
+
+    /**
+     * @param string $recoveryPassword
+     * @param string $confirmPassword
+     * @param string $adminEnableRecovery
+     * @return DataResponse
+     */
+    public function adminRecovery($recoveryPassword, $confirmPassword, $adminEnableRecovery) {
+        // Check if both passwords are the same
+        if (empty($recoveryPassword)) {
+            $errorMessage = (string)$this->l->t('Missing recovery key password');
+            return new DataResponse(['data' => ['message' => $errorMessage]],
+                Http::STATUS_BAD_REQUEST);
+        }
+
+        if (empty($confirmPassword)) {
+            $errorMessage = (string)$this->l->t('Please repeat the recovery key password');
+            return new DataResponse(['data' => ['message' => $errorMessage]],
+                Http::STATUS_BAD_REQUEST);
+        }
+
+        if ($recoveryPassword !== $confirmPassword) {
+            $errorMessage = (string)$this->l->t('Repeated recovery key password does not match the provided recovery key password');
+            return new DataResponse(['data' => ['message' => $errorMessage]],
+                Http::STATUS_BAD_REQUEST);
+        }
+
+        if (isset($adminEnableRecovery) && $adminEnableRecovery === '1') {
+            if ($this->recovery->enableAdminRecovery($recoveryPassword)) {
+                return new DataResponse(['data' => ['message' => (string)$this->l->t('Recovery key successfully enabled')]]);
+            }
+            return new DataResponse(['data' => ['message' => (string)$this->l->t('Could not enable recovery key. Please check your recovery key password!')]], Http::STATUS_BAD_REQUEST);
+        } elseif (isset($adminEnableRecovery) && $adminEnableRecovery === '0') {
+            if ($this->recovery->disableAdminRecovery($recoveryPassword)) {
+                return new DataResponse(['data' => ['message' => (string)$this->l->t('Recovery key successfully disabled')]]);
+            }
+            return new DataResponse(['data' => ['message' => (string)$this->l->t('Could not disable recovery key. Please check your recovery key password!')]], Http::STATUS_BAD_REQUEST);
+        }
+        // this response should never be sent but just in case.
+        return new DataResponse(['data' => ['message' => (string)$this->l->t('Missing parameters')]], Http::STATUS_BAD_REQUEST);
+    }
+
+    /**
+     * @param string $newPassword
+     * @param string $oldPassword
+     * @param string $confirmPassword
+     * @return DataResponse
+     */
+    public function changeRecoveryPassword($newPassword, $oldPassword, $confirmPassword) {
+        //check if both passwords are the same
+        if (empty($oldPassword)) {
+            $errorMessage = (string)$this->l->t('Please provide the old recovery password');
+            return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
+        }
+
+        if (empty($newPassword)) {
+            $errorMessage = (string)$this->l->t('Please provide a new recovery password');
+            return new DataResponse (['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
+        }
+
+        if (empty($confirmPassword)) {
+            $errorMessage = (string)$this->l->t('Please repeat the new recovery password');
+            return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
+        }
+
+        if ($newPassword !== $confirmPassword) {
+            $errorMessage = (string)$this->l->t('Repeated recovery key password does not match the provided recovery key password');
+            return new DataResponse(['data' => ['message' => $errorMessage]], Http::STATUS_BAD_REQUEST);
+        }
+
+        $result = $this->recovery->changeRecoveryKeyPassword($newPassword,
+            $oldPassword);
+
+        if ($result) {
+            return new DataResponse(
+                [
+                    'data' => [
+                        'message' => (string)$this->l->t('Password successfully changed.')]
+                ]
+            );
+        }
+        return new DataResponse(
+            [
+                'data' => [
+                    'message' => (string)$this->l->t('Could not change the password. Maybe the old password was not correct.')
+                ]
+            ], Http::STATUS_BAD_REQUEST);
+    }
+
+    /**
+     * @NoAdminRequired
+     *
+     * @param string $userEnableRecovery
+     * @return DataResponse
+     */
+    public function userSetRecovery($userEnableRecovery) {
+        if ($userEnableRecovery === '0' || $userEnableRecovery === '1') {
+
+            $result = $this->recovery->setRecoveryForUser($userEnableRecovery);
+
+            if ($result) {
+                if ($userEnableRecovery === '0') {
+                    return new DataResponse(
+                        [
+                            'data' => [
+                                'message' => (string)$this->l->t('Recovery Key disabled')]
+                        ]
+                    );
+                }
+                return new DataResponse(
+                    [
+                        'data' => [
+                            'message' => (string)$this->l->t('Recovery Key enabled')]
+                    ]
+                );
+            }
+
+        }
+        return new DataResponse(
+            [
+                'data' => [
+                    'message' => (string)$this->l->t('Could not enable the recovery key, please try again or contact your administrator')
+                ]
+            ], Http::STATUS_BAD_REQUEST);
+    }
 
 }

apps/encryption/lib/Exceptions/PublicKeyMissingException.php

Indentation +9 added lines, -9 removed lines

@@ -25,14 +25,14 @@
 
 class PublicKeyMissingException extends GenericEncryptionException {
 
-	/**
-	 * @param string $userId
-	 */
-	public function __construct($userId) {
-		if(empty($userId)) {
-			$userId = "<no-user-id-given>";
-		}
-		parent::__construct("Public Key missing for user: $userId");
-	}
+    /**
+     * @param string $userId
+     */
+    public function __construct($userId) {
+        if(empty($userId)) {
+            $userId = "<no-user-id-given>";
+        }
+        parent::__construct("Public Key missing for user: $userId");
+    }
 
 }

Spacing +1 added lines, -1 removed lines

@@ -29,7 +29,7 @@
 	 * @param string $userId
 	 */
 	public function __construct($userId) {
-		if(empty($userId)) {
+		if (empty($userId)) {
 			$userId = "<no-user-id-given>";
 		}
 		parent::__construct("Public Key missing for user: $userId");

apps/encryption/lib/Exceptions/PrivateKeyMissingException.php

Indentation +9 added lines, -9 removed lines

@@ -28,14 +28,14 @@
 
 class PrivateKeyMissingException extends GenericEncryptionException {
 
-	/**
-	 * @param string $userId
-	 */
-	public function __construct($userId) {
-		if(empty($userId)) {
-			$userId = "<no-user-id-given>";
-		}
-		parent::__construct("Private Key missing for user: $userId");
-	}
+    /**
+     * @param string $userId
+     */
+    public function __construct($userId) {
+        if(empty($userId)) {
+            $userId = "<no-user-id-given>";
+        }
+        parent::__construct("Private Key missing for user: $userId");
+    }
 
 }

Spacing +1 added lines, -1 removed lines

@@ -32,7 +32,7 @@
 	 * @param string $userId
 	 */
 	public function __construct($userId) {
-		if(empty($userId)) {
+		if (empty($userId)) {
 			$userId = "<no-user-id-given>";
 		}
 		parent::__construct("Private Key missing for user: $userId");

apps/encryption/lib/Recovery.php

Spacing +10 added lines, -10 removed lines

@@ -109,7 +109,7 @@ 
 
 		if (!$keyManager->recoveryKeyExists()) {
 			$keyPair = $this->crypt->createKeyPair();
-			if(!is_array($keyPair)) {
+			if (!is_array($keyPair)) {
 				return false;
 			}
 
@@ -134,13 +134,13 @@ 
 	public function changeRecoveryKeyPassword($newPassword, $oldPassword) {
 		$recoveryKey = $this->keyManager->getSystemPrivateKey($this->keyManager->getRecoveryKeyId());
 		$decryptedRecoveryKey = $this->crypt->decryptPrivateKey($recoveryKey, $oldPassword);
-		if($decryptedRecoveryKey === false) {
+		if ($decryptedRecoveryKey === false) {
 			return false;
 		}
 		$encryptedRecoveryKey = $this->crypt->encryptPrivateKey($decryptedRecoveryKey, $newPassword);
 		$header = $this->crypt->generateHeader();
 		if ($encryptedRecoveryKey) {
-			$this->keyManager->setSystemPrivateKey($this->keyManager->getRecoveryKeyId(), $header . $encryptedRecoveryKey);
+			$this->keyManager->setSystemPrivateKey($this->keyManager->getRecoveryKeyId(), $header.$encryptedRecoveryKey);
 			return true;
 		}
 		return false;
@@ -202,9 +202,9 @@ 
 				$value);
 
 			if ($value === '1') {
-				$this->addRecoveryKeys('/' . $this->user->getUID() . '/files/');
+				$this->addRecoveryKeys('/'.$this->user->getUID().'/files/');
 			} else {
-				$this->removeRecoveryKeys('/' . $this->user->getUID() . '/files/');
+				$this->removeRecoveryKeys('/'.$this->user->getUID().'/files/');
 			}
 
 			return true;
@@ -222,7 +222,7 @@ 
 		foreach ($dirContent as $item) {
 			$filePath = $item->getPath();
 			if ($item['type'] === 'dir') {
-				$this->addRecoveryKeys($filePath . '/');
+				$this->addRecoveryKeys($filePath.'/');
 			} else {
 				$fileKey = $this->keyManager->getFileKey($filePath, $this->user->getUID());
 				if (!empty($fileKey)) {
@@ -250,7 +250,7 @@ 
 		foreach ($dirContent as $item) {
 			$filePath = $item->getPath();
 			if ($item['type'] === 'dir') {
-				$this->removeRecoveryKeys($filePath . '/');
+				$this->removeRecoveryKeys($filePath.'/');
 			} else {
 				$this->keyManager->deleteShareKey($filePath, $this->keyManager->getRecoveryKeyId());
 			}
@@ -267,8 +267,8 @@ 
 		$encryptedKey = $this->keyManager->getSystemPrivateKey($this->keyManager->getRecoveryKeyId());
 
 		$privateKey = $this->crypt->decryptPrivateKey($encryptedKey, $recoveryPassword);
-		if($privateKey !== false) {
-			$this->recoverAllFiles('/' . $user . '/files/', $privateKey, $user);
+		if ($privateKey !== false) {
+			$this->recoverAllFiles('/'.$user.'/files/', $privateKey, $user);
 		}
 	}
 
@@ -286,7 +286,7 @@ 
 			// Get relative path from encryption/keyfiles
 			$filePath = $item->getPath();
 			if ($this->view->is_dir($filePath)) {
-				$this->recoverAllFiles($filePath . '/', $privateKey, $uid);
+				$this->recoverAllFiles($filePath.'/', $privateKey, $uid);
 			} else {
 				$this->recoverFile($filePath, $privateKey, $uid);
 			}

Indentation +273 added lines, -273 removed lines

@@ -38,279 +38,279 @@
 class Recovery {
 
 
-	/**
-	 * @var null|IUser
-	 */
-	protected $user;
-	/**
-	 * @var Crypt
-	 */
-	protected $crypt;
-	/**
-	 * @var KeyManager
-	 */
-	private $keyManager;
-	/**
-	 * @var IConfig
-	 */
-	private $config;
-	/**
-	 * @var View
-	 */
-	private $view;
-	/**
-	 * @var IFile
-	 */
-	private $file;
-
-	/**
-	 * @param IUserSession $userSession
-	 * @param Crypt $crypt
-	 * @param KeyManager $keyManager
-	 * @param IConfig $config
-	 * @param IFile $file
-	 * @param View $view
-	 */
-	public function __construct(IUserSession $userSession,
-								Crypt $crypt,
-								KeyManager $keyManager,
-								IConfig $config,
-								IFile $file,
-								View $view) {
-		$this->user = ($userSession && $userSession->isLoggedIn()) ? $userSession->getUser() : false;
-		$this->crypt = $crypt;
-		$this->keyManager = $keyManager;
-		$this->config = $config;
-		$this->view = $view;
-		$this->file = $file;
-	}
-
-	/**
-	 * @param string $password
-	 * @return bool
-	 */
-	public function enableAdminRecovery($password) {
-		$appConfig = $this->config;
-		$keyManager = $this->keyManager;
-
-		if (!$keyManager->recoveryKeyExists()) {
-			$keyPair = $this->crypt->createKeyPair();
-			if(!is_array($keyPair)) {
-				return false;
-			}
-
-			$this->keyManager->setRecoveryKey($password, $keyPair);
-		}
-
-		if ($keyManager->checkRecoveryPassword($password)) {
-			$appConfig->setAppValue('encryption', 'recoveryAdminEnabled', 1);
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * change recovery key id
-	 *
-	 * @param string $newPassword
-	 * @param string $oldPassword
-	 * @return bool
-	 */
-	public function changeRecoveryKeyPassword($newPassword, $oldPassword) {
-		$recoveryKey = $this->keyManager->getSystemPrivateKey($this->keyManager->getRecoveryKeyId());
-		$decryptedRecoveryKey = $this->crypt->decryptPrivateKey($recoveryKey, $oldPassword);
-		if($decryptedRecoveryKey === false) {
-			return false;
-		}
-		$encryptedRecoveryKey = $this->crypt->encryptPrivateKey($decryptedRecoveryKey, $newPassword);
-		$header = $this->crypt->generateHeader();
-		if ($encryptedRecoveryKey) {
-			$this->keyManager->setSystemPrivateKey($this->keyManager->getRecoveryKeyId(), $header . $encryptedRecoveryKey);
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * @param string $recoveryPassword
-	 * @return bool
-	 */
-	public function disableAdminRecovery($recoveryPassword) {
-		$keyManager = $this->keyManager;
-
-		if ($keyManager->checkRecoveryPassword($recoveryPassword)) {
-			// Set recoveryAdmin as disabled
-			$this->config->setAppValue('encryption', 'recoveryAdminEnabled', 0);
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * check if recovery is enabled for user
-	 *
-	 * @param string $user if no user is given we check the current logged-in user
-	 *
-	 * @return bool
-	 */
-	public function isRecoveryEnabledForUser($user = '') {
-		$uid = $user === '' ? $this->user->getUID() : $user;
-		$recoveryMode = $this->config->getUserValue($uid,
-			'encryption',
-			'recoveryEnabled',
-			0);
-
-		return ($recoveryMode === '1');
-	}
-
-	/**
-	 * check if recovery is key is enabled by the administrator
-	 *
-	 * @return bool
-	 */
-	public function isRecoveryKeyEnabled() {
-		$enabled = $this->config->getAppValue('encryption', 'recoveryAdminEnabled', 0);
-
-		return ($enabled === '1');
-	}
-
-	/**
-	 * @param string $value
-	 * @return bool
-	 */
-	public function setRecoveryForUser($value) {
-
-		try {
-			$this->config->setUserValue($this->user->getUID(),
-				'encryption',
-				'recoveryEnabled',
-				$value);
-
-			if ($value === '1') {
-				$this->addRecoveryKeys('/' . $this->user->getUID() . '/files/');
-			} else {
-				$this->removeRecoveryKeys('/' . $this->user->getUID() . '/files/');
-			}
-
-			return true;
-		} catch (PreConditionNotMetException $e) {
-			return false;
-		}
-	}
-
-	/**
-	 * add recovery key to all encrypted files
-	 * @param string $path
-	 */
-	private function addRecoveryKeys($path) {
-		$dirContent = $this->view->getDirectoryContent($path);
-		foreach ($dirContent as $item) {
-			$filePath = $item->getPath();
-			if ($item['type'] === 'dir') {
-				$this->addRecoveryKeys($filePath . '/');
-			} else {
-				$fileKey = $this->keyManager->getFileKey($filePath, $this->user->getUID());
-				if (!empty($fileKey)) {
-					$accessList = $this->file->getAccessList($filePath);
-					$publicKeys = [];
-					foreach ($accessList['users'] as $uid) {
-						$publicKeys[$uid] = $this->keyManager->getPublicKey($uid);
-					}
-
-					$publicKeys = $this->keyManager->addSystemKeys($accessList, $publicKeys, $this->user->getUID());
-
-					$encryptedKeyfiles = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
-					$this->keyManager->setAllFileKeys($filePath, $encryptedKeyfiles);
-				}
-			}
-		}
-	}
-
-	/**
-	 * remove recovery key to all encrypted files
-	 * @param string $path
-	 */
-	private function removeRecoveryKeys($path) {
-		$dirContent = $this->view->getDirectoryContent($path);
-		foreach ($dirContent as $item) {
-			$filePath = $item->getPath();
-			if ($item['type'] === 'dir') {
-				$this->removeRecoveryKeys($filePath . '/');
-			} else {
-				$this->keyManager->deleteShareKey($filePath, $this->keyManager->getRecoveryKeyId());
-			}
-		}
-	}
-
-	/**
-	 * recover users files with the recovery key
-	 *
-	 * @param string $recoveryPassword
-	 * @param string $user
-	 */
-	public function recoverUsersFiles($recoveryPassword, $user) {
-		$encryptedKey = $this->keyManager->getSystemPrivateKey($this->keyManager->getRecoveryKeyId());
-
-		$privateKey = $this->crypt->decryptPrivateKey($encryptedKey, $recoveryPassword);
-		if($privateKey !== false) {
-			$this->recoverAllFiles('/' . $user . '/files/', $privateKey, $user);
-		}
-	}
-
-	/**
-	 * recover users files
-	 *
-	 * @param string $path
-	 * @param string $privateKey
-	 * @param string $uid
-	 */
-	private function recoverAllFiles($path, $privateKey, $uid) {
-		$dirContent = $this->view->getDirectoryContent($path);
-
-		foreach ($dirContent as $item) {
-			// Get relative path from encryption/keyfiles
-			$filePath = $item->getPath();
-			if ($this->view->is_dir($filePath)) {
-				$this->recoverAllFiles($filePath . '/', $privateKey, $uid);
-			} else {
-				$this->recoverFile($filePath, $privateKey, $uid);
-			}
-		}
-
-	}
-
-	/**
-	 * recover file
-	 *
-	 * @param string $path
-	 * @param string $privateKey
-	 * @param string $uid
-	 */
-	private function recoverFile($path, $privateKey, $uid) {
-		$encryptedFileKey = $this->keyManager->getEncryptedFileKey($path);
-		$shareKey = $this->keyManager->getShareKey($path, $this->keyManager->getRecoveryKeyId());
-
-		if ($encryptedFileKey && $shareKey && $privateKey) {
-			$fileKey = $this->crypt->multiKeyDecrypt($encryptedFileKey,
-				$shareKey,
-				$privateKey);
-		}
-
-		if (!empty($fileKey)) {
-			$accessList = $this->file->getAccessList($path);
-			$publicKeys = [];
-			foreach ($accessList['users'] as $user) {
-				$publicKeys[$user] = $this->keyManager->getPublicKey($user);
-			}
-
-			$publicKeys = $this->keyManager->addSystemKeys($accessList, $publicKeys, $uid);
-
-			$encryptedKeyfiles = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
-			$this->keyManager->setAllFileKeys($path, $encryptedKeyfiles);
-		}
-
-	}
+    /**
+     * @var null|IUser
+     */
+    protected $user;
+    /**
+     * @var Crypt
+     */
+    protected $crypt;
+    /**
+     * @var KeyManager
+     */
+    private $keyManager;
+    /**
+     * @var IConfig
+     */
+    private $config;
+    /**
+     * @var View
+     */
+    private $view;
+    /**
+     * @var IFile
+     */
+    private $file;
+
+    /**
+     * @param IUserSession $userSession
+     * @param Crypt $crypt
+     * @param KeyManager $keyManager
+     * @param IConfig $config
+     * @param IFile $file
+     * @param View $view
+     */
+    public function __construct(IUserSession $userSession,
+                                Crypt $crypt,
+                                KeyManager $keyManager,
+                                IConfig $config,
+                                IFile $file,
+                                View $view) {
+        $this->user = ($userSession && $userSession->isLoggedIn()) ? $userSession->getUser() : false;
+        $this->crypt = $crypt;
+        $this->keyManager = $keyManager;
+        $this->config = $config;
+        $this->view = $view;
+        $this->file = $file;
+    }
+
+    /**
+     * @param string $password
+     * @return bool
+     */
+    public function enableAdminRecovery($password) {
+        $appConfig = $this->config;
+        $keyManager = $this->keyManager;
+
+        if (!$keyManager->recoveryKeyExists()) {
+            $keyPair = $this->crypt->createKeyPair();
+            if(!is_array($keyPair)) {
+                return false;
+            }
+
+            $this->keyManager->setRecoveryKey($password, $keyPair);
+        }
+
+        if ($keyManager->checkRecoveryPassword($password)) {
+            $appConfig->setAppValue('encryption', 'recoveryAdminEnabled', 1);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * change recovery key id
+     *
+     * @param string $newPassword
+     * @param string $oldPassword
+     * @return bool
+     */
+    public function changeRecoveryKeyPassword($newPassword, $oldPassword) {
+        $recoveryKey = $this->keyManager->getSystemPrivateKey($this->keyManager->getRecoveryKeyId());
+        $decryptedRecoveryKey = $this->crypt->decryptPrivateKey($recoveryKey, $oldPassword);
+        if($decryptedRecoveryKey === false) {
+            return false;
+        }
+        $encryptedRecoveryKey = $this->crypt->encryptPrivateKey($decryptedRecoveryKey, $newPassword);
+        $header = $this->crypt->generateHeader();
+        if ($encryptedRecoveryKey) {
+            $this->keyManager->setSystemPrivateKey($this->keyManager->getRecoveryKeyId(), $header . $encryptedRecoveryKey);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @param string $recoveryPassword
+     * @return bool
+     */
+    public function disableAdminRecovery($recoveryPassword) {
+        $keyManager = $this->keyManager;
+
+        if ($keyManager->checkRecoveryPassword($recoveryPassword)) {
+            // Set recoveryAdmin as disabled
+            $this->config->setAppValue('encryption', 'recoveryAdminEnabled', 0);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * check if recovery is enabled for user
+     *
+     * @param string $user if no user is given we check the current logged-in user
+     *
+     * @return bool
+     */
+    public function isRecoveryEnabledForUser($user = '') {
+        $uid = $user === '' ? $this->user->getUID() : $user;
+        $recoveryMode = $this->config->getUserValue($uid,
+            'encryption',
+            'recoveryEnabled',
+            0);
+
+        return ($recoveryMode === '1');
+    }
+
+    /**
+     * check if recovery is key is enabled by the administrator
+     *
+     * @return bool
+     */
+    public function isRecoveryKeyEnabled() {
+        $enabled = $this->config->getAppValue('encryption', 'recoveryAdminEnabled', 0);
+
+        return ($enabled === '1');
+    }
+
+    /**
+     * @param string $value
+     * @return bool
+     */
+    public function setRecoveryForUser($value) {
+
+        try {
+            $this->config->setUserValue($this->user->getUID(),
+                'encryption',
+                'recoveryEnabled',
+                $value);
+
+            if ($value === '1') {
+                $this->addRecoveryKeys('/' . $this->user->getUID() . '/files/');
+            } else {
+                $this->removeRecoveryKeys('/' . $this->user->getUID() . '/files/');
+            }
+
+            return true;
+        } catch (PreConditionNotMetException $e) {
+            return false;
+        }
+    }
+
+    /**
+     * add recovery key to all encrypted files
+     * @param string $path
+     */
+    private function addRecoveryKeys($path) {
+        $dirContent = $this->view->getDirectoryContent($path);
+        foreach ($dirContent as $item) {
+            $filePath = $item->getPath();
+            if ($item['type'] === 'dir') {
+                $this->addRecoveryKeys($filePath . '/');
+            } else {
+                $fileKey = $this->keyManager->getFileKey($filePath, $this->user->getUID());
+                if (!empty($fileKey)) {
+                    $accessList = $this->file->getAccessList($filePath);
+                    $publicKeys = [];
+                    foreach ($accessList['users'] as $uid) {
+                        $publicKeys[$uid] = $this->keyManager->getPublicKey($uid);
+                    }
+
+                    $publicKeys = $this->keyManager->addSystemKeys($accessList, $publicKeys, $this->user->getUID());
+
+                    $encryptedKeyfiles = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
+                    $this->keyManager->setAllFileKeys($filePath, $encryptedKeyfiles);
+                }
+            }
+        }
+    }
+
+    /**
+     * remove recovery key to all encrypted files
+     * @param string $path
+     */
+    private function removeRecoveryKeys($path) {
+        $dirContent = $this->view->getDirectoryContent($path);
+        foreach ($dirContent as $item) {
+            $filePath = $item->getPath();
+            if ($item['type'] === 'dir') {
+                $this->removeRecoveryKeys($filePath . '/');
+            } else {
+                $this->keyManager->deleteShareKey($filePath, $this->keyManager->getRecoveryKeyId());
+            }
+        }
+    }
+
+    /**
+     * recover users files with the recovery key
+     *
+     * @param string $recoveryPassword
+     * @param string $user
+     */
+    public function recoverUsersFiles($recoveryPassword, $user) {
+        $encryptedKey = $this->keyManager->getSystemPrivateKey($this->keyManager->getRecoveryKeyId());
+
+        $privateKey = $this->crypt->decryptPrivateKey($encryptedKey, $recoveryPassword);
+        if($privateKey !== false) {
+            $this->recoverAllFiles('/' . $user . '/files/', $privateKey, $user);
+        }
+    }
+
+    /**
+     * recover users files
+     *
+     * @param string $path
+     * @param string $privateKey
+     * @param string $uid
+     */
+    private function recoverAllFiles($path, $privateKey, $uid) {
+        $dirContent = $this->view->getDirectoryContent($path);
+
+        foreach ($dirContent as $item) {
+            // Get relative path from encryption/keyfiles
+            $filePath = $item->getPath();
+            if ($this->view->is_dir($filePath)) {
+                $this->recoverAllFiles($filePath . '/', $privateKey, $uid);
+            } else {
+                $this->recoverFile($filePath, $privateKey, $uid);
+            }
+        }
+
+    }
+
+    /**
+     * recover file
+     *
+     * @param string $path
+     * @param string $privateKey
+     * @param string $uid
+     */
+    private function recoverFile($path, $privateKey, $uid) {
+        $encryptedFileKey = $this->keyManager->getEncryptedFileKey($path);
+        $shareKey = $this->keyManager->getShareKey($path, $this->keyManager->getRecoveryKeyId());
+
+        if ($encryptedFileKey && $shareKey && $privateKey) {
+            $fileKey = $this->crypt->multiKeyDecrypt($encryptedFileKey,
+                $shareKey,
+                $privateKey);
+        }
+
+        if (!empty($fileKey)) {
+            $accessList = $this->file->getAccessList($path);
+            $publicKeys = [];
+            foreach ($accessList['users'] as $user) {
+                $publicKeys[$user] = $this->keyManager->getPublicKey($user);
+            }
+
+            $publicKeys = $this->keyManager->addSystemKeys($accessList, $publicKeys, $uid);
+
+            $encryptedKeyfiles = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
+            $this->keyManager->setAllFileKeys($path, $encryptedKeyfiles);
+        }
+
+    }
 
 
 }

apps/encryption/lib/Command/EnableMasterKey.php

Spacing +1 added lines, -1 removed lines

@@ -68,7 +68,7 @@
 
 		$isAlreadyEnabled = $this->util->isMasterKeyEnabled();
 
-		if($isAlreadyEnabled) {
+		if ($isAlreadyEnabled) {
 			$output->writeln('Master key already enabled');
 		} else {
 			$question = new ConfirmationQuestion(

Indentation +40 added lines, -40 removed lines

@@ -33,54 +33,54 @@
 
 class EnableMasterKey extends Command {
 
-	/** @var Util */
-	protected $util;
+    /** @var Util */
+    protected $util;
 
-	/** @var IConfig */
-	protected $config;
+    /** @var IConfig */
+    protected $config;
 
-	/** @var  QuestionHelper */
-	protected $questionHelper;
+    /** @var  QuestionHelper */
+    protected $questionHelper;
 
-	/**
-	 * @param Util $util
-	 * @param IConfig $config
-	 * @param QuestionHelper $questionHelper
-	 */
-	public function __construct(Util $util,
-								IConfig $config,
-								QuestionHelper $questionHelper) {
+    /**
+     * @param Util $util
+     * @param IConfig $config
+     * @param QuestionHelper $questionHelper
+     */
+    public function __construct(Util $util,
+                                IConfig $config,
+                                QuestionHelper $questionHelper) {
 
-		$this->util = $util;
-		$this->config = $config;
-		$this->questionHelper = $questionHelper;
-		parent::__construct();
-	}
+        $this->util = $util;
+        $this->config = $config;
+        $this->questionHelper = $questionHelper;
+        parent::__construct();
+    }
 
-	protected function configure() {
-		$this
-			->setName('encryption:enable-master-key')
-			->setDescription('Enable the master key. Only available for fresh installations with no existing encrypted data! There is also no way to disable it again.');
-	}
+    protected function configure() {
+        $this
+            ->setName('encryption:enable-master-key')
+            ->setDescription('Enable the master key. Only available for fresh installations with no existing encrypted data! There is also no way to disable it again.');
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output) {
+    protected function execute(InputInterface $input, OutputInterface $output) {
 
-		$isAlreadyEnabled = $this->util->isMasterKeyEnabled();
+        $isAlreadyEnabled = $this->util->isMasterKeyEnabled();
 
-		if($isAlreadyEnabled) {
-			$output->writeln('Master key already enabled');
-		} else {
-			$question = new ConfirmationQuestion(
-				'Warning: Only available for fresh installations with no existing encrypted data! '
-			. 'There is also no way to disable it again. Do you want to continue? (y/n) ', false);
-			if ($this->questionHelper->ask($input, $output, $question)) {
-				$this->config->setAppValue('encryption', 'useMasterKey', '1');
-				$output->writeln('Master key successfully enabled.');
-			} else {
-				$output->writeln('aborted.');
-			}
-		}
+        if($isAlreadyEnabled) {
+            $output->writeln('Master key already enabled');
+        } else {
+            $question = new ConfirmationQuestion(
+                'Warning: Only available for fresh installations with no existing encrypted data! '
+            . 'There is also no way to disable it again. Do you want to continue? (y/n) ', false);
+            if ($this->questionHelper->ask($input, $output, $question)) {
+                $this->config->setAppValue('encryption', 'useMasterKey', '1');
+                $output->writeln('Master key successfully enabled.');
+            } else {
+                $output->writeln('aborted.');
+            }
+        }
 
-	}
+    }
 
 }

apps/encryption/lib/Hooks/Contracts/IHook.php

Indentation +6 added lines, -6 removed lines

@@ -24,10 +24,10 @@
 
 
 interface IHook {
-	/**
-	 * Connects Hooks
-	 *
-	 * @return null
-	 */
-	public function addHooks();
+    /**
+     * Connects Hooks
+     *
+     * @return null
+     */
+    public function addHooks();
 }

apps/encryption/lib/Crypto/Encryption.php

Spacing +8 added lines, -8 removed lines

@@ -177,7 +177,7 @@ 
 		$this->isWriteOperation = false;
 		$this->writeCache = '';
 
-		if($this->session->isReady() === false) {
+		if ($this->session->isReady() === false) {
 			// if the master key is enabled we can initialize encryption
 			// with a empty password and user name
 			if ($this->util->isMasterKeyEnabled()) {
@@ -198,7 +198,7 @@ 
 		// always use the version from the original file, also part files
 		// need to have a correct version number if they get moved over to the
 		// final location
-		$this->version = (int)$this->keyManager->getVersion($this->stripPartFileExtension($path), new View());
+		$this->version = (int) $this->keyManager->getVersion($this->stripPartFileExtension($path), new View());
 
 		if (
 			$mode === 'w'
@@ -214,7 +214,7 @@ 
 			// if we read a part file we need to increase the version by 1
 			// because the version number was also increased by writing
 			// the part file
-			if(Scanner::isPartialFile($path)) {
+			if (Scanner::isPartialFile($path)) {
 				$this->version = $this->version + 1;
 			}
 		}
@@ -300,7 +300,7 @@ 
 		if ($this->writeCache) {
 
 			// Concat writeCache to start of $data
-			$data = $this->writeCache . $data;
+			$data = $this->writeCache.$data;
 
 			// Clear the write cache, ready for reuse - it has been
 			// flushed and its old contents processed
@@ -402,7 +402,7 @@ 
 					try {
 						$publicKeys[$user] = $this->keyManager->getPublicKey($user);
 					} catch (PublicKeyMissingException $e) {
-						$this->logger->warning('Could not encrypt file for ' . $user . ': ' . $e->getMessage());
+						$this->logger->warning('Could not encrypt file for '.$user.': '.$e->getMessage());
 					}
 				}
 			}
@@ -489,8 +489,8 @@ 
 				// error message because in this case it means that the file was
 				// shared with the user at a point where the user didn't had a
 				// valid private/public key
-				$msg = 'Encryption module "' . $this->getDisplayName() .
-					'" is not able to read ' . $path;
+				$msg = 'Encryption module "'.$this->getDisplayName().
+					'" is not able to read '.$path;
 				$hint = $this->l->t('Can not read this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
 				$this->logger->warning($msg);
 				throw new DecryptionFailedException($msg, $hint);
@@ -532,7 +532,7 @@ 
 		$realPath = $path;
 		$parts = explode('/', $path);
 		if ($parts[2] === 'files_versions') {
-			$realPath = '/' . $parts[1] . '/files/' . implode('/', array_slice($parts, 3));
+			$realPath = '/'.$parts[1].'/files/'.implode('/', array_slice($parts, 3));
 			$length = strrpos($realPath, '.');
 			$realPath = substr($realPath, 0, $length);
 		}

Indentation +553 added lines, -553 removed lines

@@ -46,557 +46,557 @@
 
 class Encryption implements IEncryptionModule {
 
-	const ID = 'OC_DEFAULT_MODULE';
-	const DISPLAY_NAME = 'Default encryption module';
-
-	/**
-	 * @var Crypt
-	 */
-	private $crypt;
-
-	/** @var string */
-	private $cipher;
-
-	/** @var string */
-	private $path;
-
-	/** @var string */
-	private $user;
-
-	/** @var  array */
-	private $owner;
-
-	/** @var string */
-	private $fileKey;
-
-	/** @var string */
-	private $writeCache;
-
-	/** @var KeyManager */
-	private $keyManager;
-
-	/** @var array */
-	private $accessList;
-
-	/** @var boolean */
-	private $isWriteOperation;
-
-	/** @var Util */
-	private $util;
-
-	/** @var  Session */
-	private $session;
-
-	/** @var  ILogger */
-	private $logger;
-
-	/** @var IL10N */
-	private $l;
-
-	/** @var EncryptAll */
-	private $encryptAll;
-
-	/** @var  bool */
-	private $useMasterPassword;
-
-	/** @var DecryptAll  */
-	private $decryptAll;
-
-	/** @var int unencrypted block size if block contains signature */
-	private $unencryptedBlockSizeSigned = 6072;
-
-	/** @var int unencrypted block size */
-	private $unencryptedBlockSize = 6126;
-
-	/** @var int Current version of the file */
-	private $version = 0;
-
-	/** @var array remember encryption signature version */
-	private static $rememberVersion = [];
-
-
-	/**
-	 *
-	 * @param Crypt $crypt
-	 * @param KeyManager $keyManager
-	 * @param Util $util
-	 * @param Session $session
-	 * @param EncryptAll $encryptAll
-	 * @param DecryptAll $decryptAll
-	 * @param ILogger $logger
-	 * @param IL10N $il10n
-	 */
-	public function __construct(Crypt $crypt,
-								KeyManager $keyManager,
-								Util $util,
-								Session $session,
-								EncryptAll $encryptAll,
-								DecryptAll $decryptAll,
-								ILogger $logger,
-								IL10N $il10n) {
-		$this->crypt = $crypt;
-		$this->keyManager = $keyManager;
-		$this->util = $util;
-		$this->session = $session;
-		$this->encryptAll = $encryptAll;
-		$this->decryptAll = $decryptAll;
-		$this->logger = $logger;
-		$this->l = $il10n;
-		$this->owner = [];
-		$this->useMasterPassword = $util->isMasterKeyEnabled();
-	}
-
-	/**
-	 * @return string defining the technical unique id
-	 */
-	public function getId() {
-		return self::ID;
-	}
-
-	/**
-	 * In comparison to getKey() this function returns a human readable (maybe translated) name
-	 *
-	 * @return string
-	 */
-	public function getDisplayName() {
-		return self::DISPLAY_NAME;
-	}
-
-	/**
-	 * start receiving chunks from a file. This is the place where you can
-	 * perform some initial step before starting encrypting/decrypting the
-	 * chunks
-	 *
-	 * @param string $path to the file
-	 * @param string $user who read/write the file
-	 * @param string $mode php stream open mode
-	 * @param array $header contains the header data read from the file
-	 * @param array $accessList who has access to the file contains the key 'users' and 'public'
-	 *
-	 * @return array $header contain data as key-value pairs which should be
-	 *                       written to the header, in case of a write operation
-	 *                       or if no additional data is needed return a empty array
-	 */
-	public function begin($path, $user, $mode, array $header, array $accessList) {
-		$this->path = $this->getPathToRealFile($path);
-		$this->accessList = $accessList;
-		$this->user = $user;
-		$this->isWriteOperation = false;
-		$this->writeCache = '';
-
-		if($this->session->isReady() === false) {
-			// if the master key is enabled we can initialize encryption
-			// with a empty password and user name
-			if ($this->util->isMasterKeyEnabled()) {
-				$this->keyManager->init('', '');
-			}
-		}
-
-		if ($this->session->decryptAllModeActivated()) {
-			$encryptedFileKey = $this->keyManager->getEncryptedFileKey($this->path);
-			$shareKey = $this->keyManager->getShareKey($this->path, $this->session->getDecryptAllUid());
-			$this->fileKey = $this->crypt->multiKeyDecrypt($encryptedFileKey,
-				$shareKey,
-				$this->session->getDecryptAllKey());
-		} else {
-			$this->fileKey = $this->keyManager->getFileKey($this->path, $this->user);
-		}
-
-		// always use the version from the original file, also part files
-		// need to have a correct version number if they get moved over to the
-		// final location
-		$this->version = (int)$this->keyManager->getVersion($this->stripPartFileExtension($path), new View());
-
-		if (
-			$mode === 'w'
-			|| $mode === 'w+'
-			|| $mode === 'wb'
-			|| $mode === 'wb+'
-		) {
-			$this->isWriteOperation = true;
-			if (empty($this->fileKey)) {
-				$this->fileKey = $this->crypt->generateFileKey();
-			}
-		} else {
-			// if we read a part file we need to increase the version by 1
-			// because the version number was also increased by writing
-			// the part file
-			if(Scanner::isPartialFile($path)) {
-				$this->version = $this->version + 1;
-			}
-		}
-
-		if ($this->isWriteOperation) {
-			$this->cipher = $this->crypt->getCipher();
-		} elseif (isset($header['cipher'])) {
-			$this->cipher = $header['cipher'];
-		} else {
-			// if we read a file without a header we fall-back to the legacy cipher
-			// which was used in <=oC6
-			$this->cipher = $this->crypt->getLegacyCipher();
-		}
-
-		return ['cipher' => $this->cipher, 'signed' => 'true'];
-	}
-
-	/**
-	 * last chunk received. This is the place where you can perform some final
-	 * operation and return some remaining data if something is left in your
-	 * buffer.
-	 *
-	 * @param string $path to the file
-	 * @param int $position
-	 * @return string remained data which should be written to the file in case
-	 *                of a write operation
-	 * @throws PublicKeyMissingException
-	 * @throws \Exception
-	 * @throws \OCA\Encryption\Exceptions\MultiKeyEncryptException
-	 */
-	public function end($path, $position = 0) {
-		$result = '';
-		if ($this->isWriteOperation) {
-			// in case of a part file we remember the new signature versions
-			// the version will be set later on update.
-			// This way we make sure that other apps listening to the pre-hooks
-			// still get the old version which should be the correct value for them
-			if (Scanner::isPartialFile($path)) {
-				self::$rememberVersion[$this->stripPartFileExtension($path)] = $this->version + 1;
-			}
-			if (!empty($this->writeCache)) {
-				$result = $this->crypt->symmetricEncryptFileContent($this->writeCache, $this->fileKey, $this->version + 1, $position);
-				$this->writeCache = '';
-			}
-			$publicKeys = [];
-			if ($this->useMasterPassword === true) {
-				$publicKeys[$this->keyManager->getMasterKeyId()] = $this->keyManager->getPublicMasterKey();
-			} else {
-				foreach ($this->accessList['users'] as $uid) {
-					try {
-						$publicKeys[$uid] = $this->keyManager->getPublicKey($uid);
-					} catch (PublicKeyMissingException $e) {
-						$this->logger->warning(
-							'no public key found for user "{uid}", user will not be able to read the file',
-							['app' => 'encryption', 'uid' => $uid]
-						);
-						// if the public key of the owner is missing we should fail
-						if ($uid === $this->user) {
-							throw $e;
-						}
-					}
-				}
-			}
-
-			$publicKeys = $this->keyManager->addSystemKeys($this->accessList, $publicKeys, $this->getOwner($path));
-			$encryptedKeyfiles = $this->crypt->multiKeyEncrypt($this->fileKey, $publicKeys);
-			$this->keyManager->setAllFileKeys($this->path, $encryptedKeyfiles);
-		}
-		return $result;
-	}
-
-
-
-	/**
-	 * encrypt data
-	 *
-	 * @param string $data you want to encrypt
-	 * @param int $position
-	 * @return string encrypted data
-	 */
-	public function encrypt($data, $position = 0) {
-		// If extra data is left over from the last round, make sure it
-		// is integrated into the next block
-		if ($this->writeCache) {
-
-			// Concat writeCache to start of $data
-			$data = $this->writeCache . $data;
-
-			// Clear the write cache, ready for reuse - it has been
-			// flushed and its old contents processed
-			$this->writeCache = '';
-
-		}
-
-		$encrypted = '';
-		// While there still remains some data to be processed & written
-		while (strlen($data) > 0) {
-
-			// Remaining length for this iteration, not of the
-			// entire file (may be greater than 8192 bytes)
-			$remainingLength = strlen($data);
-
-			// If data remaining to be written is less than the
-			// size of 1 6126 byte block
-			if ($remainingLength < $this->unencryptedBlockSizeSigned) {
-
-				// Set writeCache to contents of $data
-				// The writeCache will be carried over to the
-				// next write round, and added to the start of
-				// $data to ensure that written blocks are
-				// always the correct length. If there is still
-				// data in writeCache after the writing round
-				// has finished, then the data will be written
-				// to disk by $this->flush().
-				$this->writeCache = $data;
-
-				// Clear $data ready for next round
-				$data = '';
-
-			} else {
-
-				// Read the chunk from the start of $data
-				$chunk = substr($data, 0, $this->unencryptedBlockSizeSigned);
-
-				$encrypted .= $this->crypt->symmetricEncryptFileContent($chunk, $this->fileKey, $this->version + 1, $position);
-
-				// Remove the chunk we just processed from
-				// $data, leaving only unprocessed data in $data
-				// var, for handling on the next round
-				$data = substr($data, $this->unencryptedBlockSizeSigned);
-
-			}
-
-		}
-
-		return $encrypted;
-	}
-
-	/**
-	 * decrypt data
-	 *
-	 * @param string $data you want to decrypt
-	 * @param int $position
-	 * @return string decrypted data
-	 * @throws DecryptionFailedException
-	 */
-	public function decrypt($data, $position = 0) {
-		if (empty($this->fileKey)) {
-			$msg = 'Can not decrypt this file, probably this is a shared file. Please ask the file owner to reshare the file with you.';
-			$hint = $this->l->t('Can not decrypt this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
-			$this->logger->error($msg);
-
-			throw new DecryptionFailedException($msg, $hint);
-		}
-
-		return $this->crypt->symmetricDecryptFileContent($data, $this->fileKey, $this->cipher, $this->version, $position);
-	}
-
-	/**
-	 * update encrypted file, e.g. give additional users access to the file
-	 *
-	 * @param string $path path to the file which should be updated
-	 * @param string $uid of the user who performs the operation
-	 * @param array $accessList who has access to the file contains the key 'users' and 'public'
-	 * @return boolean
-	 */
-	public function update($path, $uid, array $accessList) {
-
-		if (empty($accessList)) {
-			if (isset(self::$rememberVersion[$path])) {
-				$this->keyManager->setVersion($path, self::$rememberVersion[$path], new View());
-				unset(self::$rememberVersion[$path]);
-			}
-			return;
-		}
-
-		$fileKey = $this->keyManager->getFileKey($path, $uid);
-
-		if (!empty($fileKey)) {
-
-			$publicKeys = [];
-			if ($this->useMasterPassword === true) {
-				$publicKeys[$this->keyManager->getMasterKeyId()] = $this->keyManager->getPublicMasterKey();
-			} else {
-				foreach ($accessList['users'] as $user) {
-					try {
-						$publicKeys[$user] = $this->keyManager->getPublicKey($user);
-					} catch (PublicKeyMissingException $e) {
-						$this->logger->warning('Could not encrypt file for ' . $user . ': ' . $e->getMessage());
-					}
-				}
-			}
-
-			$publicKeys = $this->keyManager->addSystemKeys($accessList, $publicKeys, $this->getOwner($path));
-
-			$encryptedFileKey = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
-
-			$this->keyManager->deleteAllFileKeys($path);
-
-			$this->keyManager->setAllFileKeys($path, $encryptedFileKey);
-
-		} else {
-			$this->logger->debug('no file key found, we assume that the file "{file}" is not encrypted',
-				['file' => $path, 'app' => 'encryption']);
-
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * should the file be encrypted or not
-	 *
-	 * @param string $path
-	 * @return boolean
-	 */
-	public function shouldEncrypt($path) {
-		if ($this->util->shouldEncryptHomeStorage() === false) {
-			$storage = $this->util->getStorage($path);
-			if ($storage->instanceOfStorage('\OCP\Files\IHomeStorage')) {
-				return false;
-			}
-		}
-		$parts = explode('/', $path);
-		if (count($parts) < 4) {
-			return false;
-		}
-
-		if ($parts[2] === 'files') {
-			return true;
-		}
-		if ($parts[2] === 'files_versions') {
-			return true;
-		}
-		if ($parts[2] === 'files_trashbin') {
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * get size of the unencrypted payload per block.
-	 * Nextcloud read/write files with a block size of 8192 byte
-	 *
-	 * @param bool $signed
-	 * @return int
-	 */
-	public function getUnencryptedBlockSize($signed = false) {
-		if ($signed === false) {
-			return $this->unencryptedBlockSize;
-		}
-
-		return $this->unencryptedBlockSizeSigned;
-	}
-
-	/**
-	 * check if the encryption module is able to read the file,
-	 * e.g. if all encryption keys exists
-	 *
-	 * @param string $path
-	 * @param string $uid user for whom we want to check if he can read the file
-	 * @return bool
-	 * @throws DecryptionFailedException
-	 */
-	public function isReadable($path, $uid) {
-		$fileKey = $this->keyManager->getFileKey($path, $uid);
-		if (empty($fileKey)) {
-			$owner = $this->util->getOwner($path);
-			if ($owner !== $uid) {
-				// if it is a shared file we throw a exception with a useful
-				// error message because in this case it means that the file was
-				// shared with the user at a point where the user didn't had a
-				// valid private/public key
-				$msg = 'Encryption module "' . $this->getDisplayName() .
-					'" is not able to read ' . $path;
-				$hint = $this->l->t('Can not read this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
-				$this->logger->warning($msg);
-				throw new DecryptionFailedException($msg, $hint);
-			}
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Initial encryption of all files
-	 *
-	 * @param InputInterface $input
-	 * @param OutputInterface $output write some status information to the terminal during encryption
-	 */
-	public function encryptAll(InputInterface $input, OutputInterface $output) {
-		$this->encryptAll->encryptAll($input, $output);
-	}
-
-	/**
-	 * prepare module to perform decrypt all operation
-	 *
-	 * @param InputInterface $input
-	 * @param OutputInterface $output
-	 * @param string $user
-	 * @return bool
-	 */
-	public function prepareDecryptAll(InputInterface $input, OutputInterface $output, $user = '') {
-		return $this->decryptAll->prepare($input, $output, $user);
-	}
-
-
-	/**
-	 * @param string $path
-	 * @return string
-	 */
-	protected function getPathToRealFile($path) {
-		$realPath = $path;
-		$parts = explode('/', $path);
-		if ($parts[2] === 'files_versions') {
-			$realPath = '/' . $parts[1] . '/files/' . implode('/', array_slice($parts, 3));
-			$length = strrpos($realPath, '.');
-			$realPath = substr($realPath, 0, $length);
-		}
-
-		return $realPath;
-	}
-
-	/**
-	 * remove .part file extension and the ocTransferId from the file to get the
-	 * original file name
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	protected function stripPartFileExtension($path) {
-		if (pathinfo($path, PATHINFO_EXTENSION) === 'part') {
-			$pos = strrpos($path, '.', -6);
-			$path = substr($path, 0, $pos);
-		}
-
-		return $path;
-	}
-
-	/**
-	 * get owner of a file
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	protected function getOwner($path) {
-		if (!isset($this->owner[$path])) {
-			$this->owner[$path] = $this->util->getOwner($path);
-		}
-		return $this->owner[$path];
-	}
-
-	/**
-	 * Check if the module is ready to be used by that specific user.
-	 * In case a module is not ready - because e.g. key pairs have not been generated
-	 * upon login this method can return false before any operation starts and might
-	 * cause issues during operations.
-	 *
-	 * @param string $user
-	 * @return boolean
-	 * @since 9.1.0
-	 */
-	public function isReadyForUser($user) {
-		return $this->keyManager->userHasKeys($user);
-	}
-
-	/**
-	 * We only need a detailed access list if the master key is not enabled
-	 *
-	 * @return bool
-	 */
-	public function needDetailedAccessList() {
-		return !$this->util->isMasterKeyEnabled();
-	}
+    const ID = 'OC_DEFAULT_MODULE';
+    const DISPLAY_NAME = 'Default encryption module';
+
+    /**
+     * @var Crypt
+     */
+    private $crypt;
+
+    /** @var string */
+    private $cipher;
+
+    /** @var string */
+    private $path;
+
+    /** @var string */
+    private $user;
+
+    /** @var  array */
+    private $owner;
+
+    /** @var string */
+    private $fileKey;
+
+    /** @var string */
+    private $writeCache;
+
+    /** @var KeyManager */
+    private $keyManager;
+
+    /** @var array */
+    private $accessList;
+
+    /** @var boolean */
+    private $isWriteOperation;
+
+    /** @var Util */
+    private $util;
+
+    /** @var  Session */
+    private $session;
+
+    /** @var  ILogger */
+    private $logger;
+
+    /** @var IL10N */
+    private $l;
+
+    /** @var EncryptAll */
+    private $encryptAll;
+
+    /** @var  bool */
+    private $useMasterPassword;
+
+    /** @var DecryptAll  */
+    private $decryptAll;
+
+    /** @var int unencrypted block size if block contains signature */
+    private $unencryptedBlockSizeSigned = 6072;
+
+    /** @var int unencrypted block size */
+    private $unencryptedBlockSize = 6126;
+
+    /** @var int Current version of the file */
+    private $version = 0;
+
+    /** @var array remember encryption signature version */
+    private static $rememberVersion = [];
+
+
+    /**
+     *
+     * @param Crypt $crypt
+     * @param KeyManager $keyManager
+     * @param Util $util
+     * @param Session $session
+     * @param EncryptAll $encryptAll
+     * @param DecryptAll $decryptAll
+     * @param ILogger $logger
+     * @param IL10N $il10n
+     */
+    public function __construct(Crypt $crypt,
+                                KeyManager $keyManager,
+                                Util $util,
+                                Session $session,
+                                EncryptAll $encryptAll,
+                                DecryptAll $decryptAll,
+                                ILogger $logger,
+                                IL10N $il10n) {
+        $this->crypt = $crypt;
+        $this->keyManager = $keyManager;
+        $this->util = $util;
+        $this->session = $session;
+        $this->encryptAll = $encryptAll;
+        $this->decryptAll = $decryptAll;
+        $this->logger = $logger;
+        $this->l = $il10n;
+        $this->owner = [];
+        $this->useMasterPassword = $util->isMasterKeyEnabled();
+    }
+
+    /**
+     * @return string defining the technical unique id
+     */
+    public function getId() {
+        return self::ID;
+    }
+
+    /**
+     * In comparison to getKey() this function returns a human readable (maybe translated) name
+     *
+     * @return string
+     */
+    public function getDisplayName() {
+        return self::DISPLAY_NAME;
+    }
+
+    /**
+     * start receiving chunks from a file. This is the place where you can
+     * perform some initial step before starting encrypting/decrypting the
+     * chunks
+     *
+     * @param string $path to the file
+     * @param string $user who read/write the file
+     * @param string $mode php stream open mode
+     * @param array $header contains the header data read from the file
+     * @param array $accessList who has access to the file contains the key 'users' and 'public'
+     *
+     * @return array $header contain data as key-value pairs which should be
+     *                       written to the header, in case of a write operation
+     *                       or if no additional data is needed return a empty array
+     */
+    public function begin($path, $user, $mode, array $header, array $accessList) {
+        $this->path = $this->getPathToRealFile($path);
+        $this->accessList = $accessList;
+        $this->user = $user;
+        $this->isWriteOperation = false;
+        $this->writeCache = '';
+
+        if($this->session->isReady() === false) {
+            // if the master key is enabled we can initialize encryption
+            // with a empty password and user name
+            if ($this->util->isMasterKeyEnabled()) {
+                $this->keyManager->init('', '');
+            }
+        }
+
+        if ($this->session->decryptAllModeActivated()) {
+            $encryptedFileKey = $this->keyManager->getEncryptedFileKey($this->path);
+            $shareKey = $this->keyManager->getShareKey($this->path, $this->session->getDecryptAllUid());
+            $this->fileKey = $this->crypt->multiKeyDecrypt($encryptedFileKey,
+                $shareKey,
+                $this->session->getDecryptAllKey());
+        } else {
+            $this->fileKey = $this->keyManager->getFileKey($this->path, $this->user);
+        }
+
+        // always use the version from the original file, also part files
+        // need to have a correct version number if they get moved over to the
+        // final location
+        $this->version = (int)$this->keyManager->getVersion($this->stripPartFileExtension($path), new View());
+
+        if (
+            $mode === 'w'
+            || $mode === 'w+'
+            || $mode === 'wb'
+            || $mode === 'wb+'
+        ) {
+            $this->isWriteOperation = true;
+            if (empty($this->fileKey)) {
+                $this->fileKey = $this->crypt->generateFileKey();
+            }
+        } else {
+            // if we read a part file we need to increase the version by 1
+            // because the version number was also increased by writing
+            // the part file
+            if(Scanner::isPartialFile($path)) {
+                $this->version = $this->version + 1;
+            }
+        }
+
+        if ($this->isWriteOperation) {
+            $this->cipher = $this->crypt->getCipher();
+        } elseif (isset($header['cipher'])) {
+            $this->cipher = $header['cipher'];
+        } else {
+            // if we read a file without a header we fall-back to the legacy cipher
+            // which was used in <=oC6
+            $this->cipher = $this->crypt->getLegacyCipher();
+        }
+
+        return ['cipher' => $this->cipher, 'signed' => 'true'];
+    }
+
+    /**
+     * last chunk received. This is the place where you can perform some final
+     * operation and return some remaining data if something is left in your
+     * buffer.
+     *
+     * @param string $path to the file
+     * @param int $position
+     * @return string remained data which should be written to the file in case
+     *                of a write operation
+     * @throws PublicKeyMissingException
+     * @throws \Exception
+     * @throws \OCA\Encryption\Exceptions\MultiKeyEncryptException
+     */
+    public function end($path, $position = 0) {
+        $result = '';
+        if ($this->isWriteOperation) {
+            // in case of a part file we remember the new signature versions
+            // the version will be set later on update.
+            // This way we make sure that other apps listening to the pre-hooks
+            // still get the old version which should be the correct value for them
+            if (Scanner::isPartialFile($path)) {
+                self::$rememberVersion[$this->stripPartFileExtension($path)] = $this->version + 1;
+            }
+            if (!empty($this->writeCache)) {
+                $result = $this->crypt->symmetricEncryptFileContent($this->writeCache, $this->fileKey, $this->version + 1, $position);
+                $this->writeCache = '';
+            }
+            $publicKeys = [];
+            if ($this->useMasterPassword === true) {
+                $publicKeys[$this->keyManager->getMasterKeyId()] = $this->keyManager->getPublicMasterKey();
+            } else {
+                foreach ($this->accessList['users'] as $uid) {
+                    try {
+                        $publicKeys[$uid] = $this->keyManager->getPublicKey($uid);
+                    } catch (PublicKeyMissingException $e) {
+                        $this->logger->warning(
+                            'no public key found for user "{uid}", user will not be able to read the file',
+                            ['app' => 'encryption', 'uid' => $uid]
+                        );
+                        // if the public key of the owner is missing we should fail
+                        if ($uid === $this->user) {
+                            throw $e;
+                        }
+                    }
+                }
+            }
+
+            $publicKeys = $this->keyManager->addSystemKeys($this->accessList, $publicKeys, $this->getOwner($path));
+            $encryptedKeyfiles = $this->crypt->multiKeyEncrypt($this->fileKey, $publicKeys);
+            $this->keyManager->setAllFileKeys($this->path, $encryptedKeyfiles);
+        }
+        return $result;
+    }
+
+
+
+    /**
+     * encrypt data
+     *
+     * @param string $data you want to encrypt
+     * @param int $position
+     * @return string encrypted data
+     */
+    public function encrypt($data, $position = 0) {
+        // If extra data is left over from the last round, make sure it
+        // is integrated into the next block
+        if ($this->writeCache) {
+
+            // Concat writeCache to start of $data
+            $data = $this->writeCache . $data;
+
+            // Clear the write cache, ready for reuse - it has been
+            // flushed and its old contents processed
+            $this->writeCache = '';
+
+        }
+
+        $encrypted = '';
+        // While there still remains some data to be processed & written
+        while (strlen($data) > 0) {
+
+            // Remaining length for this iteration, not of the
+            // entire file (may be greater than 8192 bytes)
+            $remainingLength = strlen($data);
+
+            // If data remaining to be written is less than the
+            // size of 1 6126 byte block
+            if ($remainingLength < $this->unencryptedBlockSizeSigned) {
+
+                // Set writeCache to contents of $data
+                // The writeCache will be carried over to the
+                // next write round, and added to the start of
+                // $data to ensure that written blocks are
+                // always the correct length. If there is still
+                // data in writeCache after the writing round
+                // has finished, then the data will be written
+                // to disk by $this->flush().
+                $this->writeCache = $data;
+
+                // Clear $data ready for next round
+                $data = '';
+
+            } else {
+
+                // Read the chunk from the start of $data
+                $chunk = substr($data, 0, $this->unencryptedBlockSizeSigned);
+
+                $encrypted .= $this->crypt->symmetricEncryptFileContent($chunk, $this->fileKey, $this->version + 1, $position);
+
+                // Remove the chunk we just processed from
+                // $data, leaving only unprocessed data in $data
+                // var, for handling on the next round
+                $data = substr($data, $this->unencryptedBlockSizeSigned);
+
+            }
+
+        }
+
+        return $encrypted;
+    }
+
+    /**
+     * decrypt data
+     *
+     * @param string $data you want to decrypt
+     * @param int $position
+     * @return string decrypted data
+     * @throws DecryptionFailedException
+     */
+    public function decrypt($data, $position = 0) {
+        if (empty($this->fileKey)) {
+            $msg = 'Can not decrypt this file, probably this is a shared file. Please ask the file owner to reshare the file with you.';
+            $hint = $this->l->t('Can not decrypt this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
+            $this->logger->error($msg);
+
+            throw new DecryptionFailedException($msg, $hint);
+        }
+
+        return $this->crypt->symmetricDecryptFileContent($data, $this->fileKey, $this->cipher, $this->version, $position);
+    }
+
+    /**
+     * update encrypted file, e.g. give additional users access to the file
+     *
+     * @param string $path path to the file which should be updated
+     * @param string $uid of the user who performs the operation
+     * @param array $accessList who has access to the file contains the key 'users' and 'public'
+     * @return boolean
+     */
+    public function update($path, $uid, array $accessList) {
+
+        if (empty($accessList)) {
+            if (isset(self::$rememberVersion[$path])) {
+                $this->keyManager->setVersion($path, self::$rememberVersion[$path], new View());
+                unset(self::$rememberVersion[$path]);
+            }
+            return;
+        }
+
+        $fileKey = $this->keyManager->getFileKey($path, $uid);
+
+        if (!empty($fileKey)) {
+
+            $publicKeys = [];
+            if ($this->useMasterPassword === true) {
+                $publicKeys[$this->keyManager->getMasterKeyId()] = $this->keyManager->getPublicMasterKey();
+            } else {
+                foreach ($accessList['users'] as $user) {
+                    try {
+                        $publicKeys[$user] = $this->keyManager->getPublicKey($user);
+                    } catch (PublicKeyMissingException $e) {
+                        $this->logger->warning('Could not encrypt file for ' . $user . ': ' . $e->getMessage());
+                    }
+                }
+            }
+
+            $publicKeys = $this->keyManager->addSystemKeys($accessList, $publicKeys, $this->getOwner($path));
+
+            $encryptedFileKey = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
+
+            $this->keyManager->deleteAllFileKeys($path);
+
+            $this->keyManager->setAllFileKeys($path, $encryptedFileKey);
+
+        } else {
+            $this->logger->debug('no file key found, we assume that the file "{file}" is not encrypted',
+                ['file' => $path, 'app' => 'encryption']);
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * should the file be encrypted or not
+     *
+     * @param string $path
+     * @return boolean
+     */
+    public function shouldEncrypt($path) {
+        if ($this->util->shouldEncryptHomeStorage() === false) {
+            $storage = $this->util->getStorage($path);
+            if ($storage->instanceOfStorage('\OCP\Files\IHomeStorage')) {
+                return false;
+            }
+        }
+        $parts = explode('/', $path);
+        if (count($parts) < 4) {
+            return false;
+        }
+
+        if ($parts[2] === 'files') {
+            return true;
+        }
+        if ($parts[2] === 'files_versions') {
+            return true;
+        }
+        if ($parts[2] === 'files_trashbin') {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * get size of the unencrypted payload per block.
+     * Nextcloud read/write files with a block size of 8192 byte
+     *
+     * @param bool $signed
+     * @return int
+     */
+    public function getUnencryptedBlockSize($signed = false) {
+        if ($signed === false) {
+            return $this->unencryptedBlockSize;
+        }
+
+        return $this->unencryptedBlockSizeSigned;
+    }
+
+    /**
+     * check if the encryption module is able to read the file,
+     * e.g. if all encryption keys exists
+     *
+     * @param string $path
+     * @param string $uid user for whom we want to check if he can read the file
+     * @return bool
+     * @throws DecryptionFailedException
+     */
+    public function isReadable($path, $uid) {
+        $fileKey = $this->keyManager->getFileKey($path, $uid);
+        if (empty($fileKey)) {
+            $owner = $this->util->getOwner($path);
+            if ($owner !== $uid) {
+                // if it is a shared file we throw a exception with a useful
+                // error message because in this case it means that the file was
+                // shared with the user at a point where the user didn't had a
+                // valid private/public key
+                $msg = 'Encryption module "' . $this->getDisplayName() .
+                    '" is not able to read ' . $path;
+                $hint = $this->l->t('Can not read this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
+                $this->logger->warning($msg);
+                throw new DecryptionFailedException($msg, $hint);
+            }
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Initial encryption of all files
+     *
+     * @param InputInterface $input
+     * @param OutputInterface $output write some status information to the terminal during encryption
+     */
+    public function encryptAll(InputInterface $input, OutputInterface $output) {
+        $this->encryptAll->encryptAll($input, $output);
+    }
+
+    /**
+     * prepare module to perform decrypt all operation
+     *
+     * @param InputInterface $input
+     * @param OutputInterface $output
+     * @param string $user
+     * @return bool
+     */
+    public function prepareDecryptAll(InputInterface $input, OutputInterface $output, $user = '') {
+        return $this->decryptAll->prepare($input, $output, $user);
+    }
+
+
+    /**
+     * @param string $path
+     * @return string
+     */
+    protected function getPathToRealFile($path) {
+        $realPath = $path;
+        $parts = explode('/', $path);
+        if ($parts[2] === 'files_versions') {
+            $realPath = '/' . $parts[1] . '/files/' . implode('/', array_slice($parts, 3));
+            $length = strrpos($realPath, '.');
+            $realPath = substr($realPath, 0, $length);
+        }
+
+        return $realPath;
+    }
+
+    /**
+     * remove .part file extension and the ocTransferId from the file to get the
+     * original file name
+     *
+     * @param string $path
+     * @return string
+     */
+    protected function stripPartFileExtension($path) {
+        if (pathinfo($path, PATHINFO_EXTENSION) === 'part') {
+            $pos = strrpos($path, '.', -6);
+            $path = substr($path, 0, $pos);
+        }
+
+        return $path;
+    }
+
+    /**
+     * get owner of a file
+     *
+     * @param string $path
+     * @return string
+     */
+    protected function getOwner($path) {
+        if (!isset($this->owner[$path])) {
+            $this->owner[$path] = $this->util->getOwner($path);
+        }
+        return $this->owner[$path];
+    }
+
+    /**
+     * Check if the module is ready to be used by that specific user.
+     * In case a module is not ready - because e.g. key pairs have not been generated
+     * upon login this method can return false before any operation starts and might
+     * cause issues during operations.
+     *
+     * @param string $user
+     * @return boolean
+     * @since 9.1.0
+     */
+    public function isReadyForUser($user) {
+        return $this->keyManager->userHasKeys($user);
+    }
+
+    /**
+     * We only need a detailed access list if the master key is not enabled
+     *
+     * @return bool
+     */
+    public function needDetailedAccessList() {
+        return !$this->util->isMasterKeyEnabled();
+    }
 }

apps/encryption/lib/Crypto/DecryptAll.php

Indentation +123 added lines, -123 removed lines

@@ -35,127 +35,127 @@
 
 class DecryptAll {
 
-	/** @var Util  */
-	protected $util;
-
-	/** @var QuestionHelper  */
-	protected $questionHelper;
-
-	/** @var  Crypt */
-	protected $crypt;
-
-	/** @var  KeyManager */
-	protected $keyManager;
-
-	/** @var Session  */
-	protected $session;
-
-	/**
-	 * @param Util $util
-	 * @param KeyManager $keyManager
-	 * @param Crypt $crypt
-	 * @param Session $session
-	 * @param QuestionHelper $questionHelper
-	 */
-	public function __construct(
-		Util $util,
-		KeyManager $keyManager,
-		Crypt $crypt,
-		Session $session,
-		QuestionHelper $questionHelper
-	) {
-		$this->util = $util;
-		$this->keyManager = $keyManager;
-		$this->crypt = $crypt;
-		$this->session = $session;
-		$this->questionHelper = $questionHelper;
-	}
-
-	/**
-	 * prepare encryption module to decrypt all files
-	 *
-	 * @param InputInterface $input
-	 * @param OutputInterface $output
-	 * @param $user
-	 * @return bool
-	 */
-	public function prepare(InputInterface $input, OutputInterface $output, $user) {
-
-		$question = new Question('Please enter the recovery key password: ');
-
-		if($this->util->isMasterKeyEnabled()) {
-			$output->writeln('Use master key to decrypt all files');
-			$user = $this->keyManager->getMasterKeyId();
-			$password =$this->keyManager->getMasterKeyPassword();
-		} else {
-			$recoveryKeyId = $this->keyManager->getRecoveryKeyId();
-			if (!empty($user)) {
-				$output->writeln('You can only decrypt the users files if you know');
-				$output->writeln('the users password or if he activated the recovery key.');
-				$output->writeln('');
-				$questionUseLoginPassword = new ConfirmationQuestion(
-					'Do you want to use the users login password to decrypt all files? (y/n) ',
-					false
-				);
-				$useLoginPassword = $this->questionHelper->ask($input, $output, $questionUseLoginPassword);
-				if ($useLoginPassword) {
-					$question = new Question('Please enter the user\'s login password: ');
-				} else if ($this->util->isRecoveryEnabledForUser($user) === false) {
-					$output->writeln('No recovery key available for user ' . $user);
-					return false;
-				} else {
-					$user = $recoveryKeyId;
-				}
-			} else {
-				$output->writeln('You can only decrypt the files of all users if the');
-				$output->writeln('recovery key is enabled by the admin and activated by the users.');
-				$output->writeln('');
-				$user = $recoveryKeyId;
-			}
-
-			$question->setHidden(true);
-			$question->setHiddenFallback(false);
-			$password = $this->questionHelper->ask($input, $output, $question);
-		}
-
-		$privateKey = $this->getPrivateKey($user, $password);
-		if ($privateKey !== false) {
-			$this->updateSession($user, $privateKey);
-			return true;
-		} else {
-			$output->writeln('Could not decrypt private key, maybe you entered the wrong password?');
-		}
-
-
-		return false;
-	}
-
-	/**
-	 * get the private key which will be used to decrypt all files
-	 *
-	 * @param string $user
-	 * @param string $password
-	 * @return bool|string
-	 * @throws \OCA\Encryption\Exceptions\PrivateKeyMissingException
-	 */
-	protected function getPrivateKey($user, $password) {
-		$recoveryKeyId = $this->keyManager->getRecoveryKeyId();
-		$masterKeyId = $this->keyManager->getMasterKeyId();
-		if ($user === $recoveryKeyId) {
-			$recoveryKey = $this->keyManager->getSystemPrivateKey($recoveryKeyId);
-			$privateKey = $this->crypt->decryptPrivateKey($recoveryKey, $password);
-		} elseif ($user === $masterKeyId) {
-			$masterKey = $this->keyManager->getSystemPrivateKey($masterKeyId);
-			$privateKey = $this->crypt->decryptPrivateKey($masterKey, $password, $masterKeyId);
-		} else {
-			$userKey = $this->keyManager->getPrivateKey($user);
-			$privateKey = $this->crypt->decryptPrivateKey($userKey, $password, $user);
-		}
-
-		return $privateKey;
-	}
-
-	protected function updateSession($user, $privateKey) {
-		$this->session->prepareDecryptAll($user, $privateKey);
-	}
+    /** @var Util  */
+    protected $util;
+
+    /** @var QuestionHelper  */
+    protected $questionHelper;
+
+    /** @var  Crypt */
+    protected $crypt;
+
+    /** @var  KeyManager */
+    protected $keyManager;
+
+    /** @var Session  */
+    protected $session;
+
+    /**
+     * @param Util $util
+     * @param KeyManager $keyManager
+     * @param Crypt $crypt
+     * @param Session $session
+     * @param QuestionHelper $questionHelper
+     */
+    public function __construct(
+        Util $util,
+        KeyManager $keyManager,
+        Crypt $crypt,
+        Session $session,
+        QuestionHelper $questionHelper
+    ) {
+        $this->util = $util;
+        $this->keyManager = $keyManager;
+        $this->crypt = $crypt;
+        $this->session = $session;
+        $this->questionHelper = $questionHelper;
+    }
+
+    /**
+     * prepare encryption module to decrypt all files
+     *
+     * @param InputInterface $input
+     * @param OutputInterface $output
+     * @param $user
+     * @return bool
+     */
+    public function prepare(InputInterface $input, OutputInterface $output, $user) {
+
+        $question = new Question('Please enter the recovery key password: ');
+
+        if($this->util->isMasterKeyEnabled()) {
+            $output->writeln('Use master key to decrypt all files');
+            $user = $this->keyManager->getMasterKeyId();
+            $password =$this->keyManager->getMasterKeyPassword();
+        } else {
+            $recoveryKeyId = $this->keyManager->getRecoveryKeyId();
+            if (!empty($user)) {
+                $output->writeln('You can only decrypt the users files if you know');
+                $output->writeln('the users password or if he activated the recovery key.');
+                $output->writeln('');
+                $questionUseLoginPassword = new ConfirmationQuestion(
+                    'Do you want to use the users login password to decrypt all files? (y/n) ',
+                    false
+                );
+                $useLoginPassword = $this->questionHelper->ask($input, $output, $questionUseLoginPassword);
+                if ($useLoginPassword) {
+                    $question = new Question('Please enter the user\'s login password: ');
+                } else if ($this->util->isRecoveryEnabledForUser($user) === false) {
+                    $output->writeln('No recovery key available for user ' . $user);
+                    return false;
+                } else {
+                    $user = $recoveryKeyId;
+                }
+            } else {
+                $output->writeln('You can only decrypt the files of all users if the');
+                $output->writeln('recovery key is enabled by the admin and activated by the users.');
+                $output->writeln('');
+                $user = $recoveryKeyId;
+            }
+
+            $question->setHidden(true);
+            $question->setHiddenFallback(false);
+            $password = $this->questionHelper->ask($input, $output, $question);
+        }
+
+        $privateKey = $this->getPrivateKey($user, $password);
+        if ($privateKey !== false) {
+            $this->updateSession($user, $privateKey);
+            return true;
+        } else {
+            $output->writeln('Could not decrypt private key, maybe you entered the wrong password?');
+        }
+
+
+        return false;
+    }
+
+    /**
+     * get the private key which will be used to decrypt all files
+     *
+     * @param string $user
+     * @param string $password
+     * @return bool|string
+     * @throws \OCA\Encryption\Exceptions\PrivateKeyMissingException
+     */
+    protected function getPrivateKey($user, $password) {
+        $recoveryKeyId = $this->keyManager->getRecoveryKeyId();
+        $masterKeyId = $this->keyManager->getMasterKeyId();
+        if ($user === $recoveryKeyId) {
+            $recoveryKey = $this->keyManager->getSystemPrivateKey($recoveryKeyId);
+            $privateKey = $this->crypt->decryptPrivateKey($recoveryKey, $password);
+        } elseif ($user === $masterKeyId) {
+            $masterKey = $this->keyManager->getSystemPrivateKey($masterKeyId);
+            $privateKey = $this->crypt->decryptPrivateKey($masterKey, $password, $masterKeyId);
+        } else {
+            $userKey = $this->keyManager->getPrivateKey($user);
+            $privateKey = $this->crypt->decryptPrivateKey($userKey, $password, $user);
+        }
+
+        return $privateKey;
+    }
+
+    protected function updateSession($user, $privateKey) {
+        $this->session->prepareDecryptAll($user, $privateKey);
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -83,10 +83,10 @@ 
 
 		$question = new Question('Please enter the recovery key password: ');
 
-		if($this->util->isMasterKeyEnabled()) {
+		if ($this->util->isMasterKeyEnabled()) {
 			$output->writeln('Use master key to decrypt all files');
 			$user = $this->keyManager->getMasterKeyId();
-			$password =$this->keyManager->getMasterKeyPassword();
+			$password = $this->keyManager->getMasterKeyPassword();
 		} else {
 			$recoveryKeyId = $this->keyManager->getRecoveryKeyId();
 			if (!empty($user)) {
@@ -101,7 +101,7 @@ 
 				if ($useLoginPassword) {
 					$question = new Question('Please enter the user\'s login password: ');
 				} else if ($this->util->isRecoveryEnabledForUser($user) === false) {
-					$output->writeln('No recovery key available for user ' . $user);
+					$output->writeln('No recovery key available for user '.$user);
 					return false;
 				} else {
 					$user = $recoveryKeyId;