nextcloud / server

apps/encryption/lib/Command/DropLegacyFileKey.php

Indentation +127 added lines, -127 removed lines

@@ -20,131 +20,131 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class DropLegacyFileKey extends Command {
-	private View $rootView;
-
-	public function __construct(
-		private IUserManager $userManager,
-		private KeyManager $keyManager,
-	) {
-		parent::__construct();
-
-		$this->rootView = new View();
-	}
-
-	protected function configure(): void {
-		$this
-			->setName('encryption:drop-legacy-filekey')
-			->setDescription('Scan the files for the legacy filekey format using RC4 and get rid of it (if master key is enabled)');
-	}
-
-	protected function execute(InputInterface $input, OutputInterface $output): int {
-		$result = true;
-
-		$output->writeln('<info>Scanning all files for legacy filekey</info>');
-
-		foreach ($this->userManager->getBackends() as $backend) {
-			$limit = 500;
-			$offset = 0;
-			do {
-				$users = $backend->getUsers('', $limit, $offset);
-				foreach ($users as $user) {
-					$output->writeln('Scanning all files for ' . $user);
-					$this->setupUserFS($user);
-					$result = $result && $this->scanFolder($output, '/' . $user);
-				}
-				$offset += $limit;
-			} while (count($users) >= $limit);
-		}
-
-		if ($result) {
-			$output->writeln('All scanned files are properly encrypted.');
-			return self::SUCCESS;
-		}
-
-		return self::FAILURE;
-	}
-
-	private function scanFolder(OutputInterface $output, string $folder): bool {
-		$clean = true;
-
-		foreach ($this->rootView->getDirectoryContent($folder) as $item) {
-			$path = $folder . '/' . $item['name'];
-			if ($this->rootView->is_dir($path)) {
-				if ($this->scanFolder($output, $path) === false) {
-					$clean = false;
-				}
-			} else {
-				if (!$item->isEncrypted()) {
-					// ignore
-					continue;
-				}
-
-				$stats = $this->rootView->stat($path);
-				if (!isset($stats['hasHeader']) || $stats['hasHeader'] === false) {
-					$clean = false;
-					$output->writeln('<error>' . $path . ' does not have a proper header</error>');
-				} else {
-					try {
-						$legacyFileKey = $this->keyManager->getFileKey($path, true);
-						if ($legacyFileKey === '') {
-							$output->writeln('Got an empty legacy filekey for ' . $path . ', continuing', OutputInterface::VERBOSITY_VERBOSE);
-							continue;
-						}
-					} catch (GenericEncryptionException $e) {
-						$output->writeln('Got a decryption error for legacy filekey for ' . $path . ', continuing', OutputInterface::VERBOSITY_VERBOSE);
-						continue;
-					}
-					/* If that did not throw and filekey is not empty, a legacy filekey is used */
-					$clean = false;
-					$output->writeln($path . ' is using a legacy filekey, migrating');
-					$this->migrateSinglefile($path, $item, $output);
-				}
-			}
-		}
-
-		return $clean;
-	}
-
-	private function migrateSinglefile(string $path, FileInfo $fileInfo, OutputInterface $output): void {
-		$source = $path;
-		$target = $path . '.reencrypted.' . time();
-
-		try {
-			$this->rootView->copy($source, $target);
-			$copyResource = $this->rootView->fopen($target, 'r');
-			$sourceResource = $this->rootView->fopen($source, 'w');
-			if ($copyResource === false || $sourceResource === false) {
-				throw new DecryptionFailedException('Failed to open ' . $source . ' or ' . $target);
-			}
-			if (stream_copy_to_stream($copyResource, $sourceResource) === false) {
-				$output->writeln('<error>Failed to copy ' . $target . ' data into ' . $source . '</error>');
-				$output->writeln('<error>Leaving both files in there to avoid data loss</error>');
-				return;
-			}
-			$this->rootView->touch($source, $fileInfo->getMTime());
-			$this->rootView->unlink($target);
-			$output->writeln('<info>Migrated ' . $source . '</info>', OutputInterface::VERBOSITY_VERBOSE);
-		} catch (DecryptionFailedException $e) {
-			if ($this->rootView->file_exists($target)) {
-				$this->rootView->unlink($target);
-			}
-			$output->writeln('<error>Failed to migrate ' . $path . '</error>');
-			$output->writeln('<error>' . $e . '</error>', OutputInterface::VERBOSITY_VERBOSE);
-		} finally {
-			if (is_resource($copyResource)) {
-				fclose($copyResource);
-			}
-			if (is_resource($sourceResource)) {
-				fclose($sourceResource);
-			}
-		}
-	}
-
-	/**
-	 * setup user file system
-	 */
-	protected function setupUserFS(string $uid): void {
-		\OC_Util::tearDownFS();
-		\OC_Util::setupFS($uid);
-	}
+    private View $rootView;
+
+    public function __construct(
+        private IUserManager $userManager,
+        private KeyManager $keyManager,
+    ) {
+        parent::__construct();
+
+        $this->rootView = new View();
+    }
+
+    protected function configure(): void {
+        $this
+            ->setName('encryption:drop-legacy-filekey')
+            ->setDescription('Scan the files for the legacy filekey format using RC4 and get rid of it (if master key is enabled)');
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        $result = true;
+
+        $output->writeln('<info>Scanning all files for legacy filekey</info>');
+
+        foreach ($this->userManager->getBackends() as $backend) {
+            $limit = 500;
+            $offset = 0;
+            do {
+                $users = $backend->getUsers('', $limit, $offset);
+                foreach ($users as $user) {
+                    $output->writeln('Scanning all files for ' . $user);
+                    $this->setupUserFS($user);
+                    $result = $result && $this->scanFolder($output, '/' . $user);
+                }
+                $offset += $limit;
+            } while (count($users) >= $limit);
+        }
+
+        if ($result) {
+            $output->writeln('All scanned files are properly encrypted.');
+            return self::SUCCESS;
+        }
+
+        return self::FAILURE;
+    }
+
+    private function scanFolder(OutputInterface $output, string $folder): bool {
+        $clean = true;
+
+        foreach ($this->rootView->getDirectoryContent($folder) as $item) {
+            $path = $folder . '/' . $item['name'];
+            if ($this->rootView->is_dir($path)) {
+                if ($this->scanFolder($output, $path) === false) {
+                    $clean = false;
+                }
+            } else {
+                if (!$item->isEncrypted()) {
+                    // ignore
+                    continue;
+                }
+
+                $stats = $this->rootView->stat($path);
+                if (!isset($stats['hasHeader']) || $stats['hasHeader'] === false) {
+                    $clean = false;
+                    $output->writeln('<error>' . $path . ' does not have a proper header</error>');
+                } else {
+                    try {
+                        $legacyFileKey = $this->keyManager->getFileKey($path, true);
+                        if ($legacyFileKey === '') {
+                            $output->writeln('Got an empty legacy filekey for ' . $path . ', continuing', OutputInterface::VERBOSITY_VERBOSE);
+                            continue;
+                        }
+                    } catch (GenericEncryptionException $e) {
+                        $output->writeln('Got a decryption error for legacy filekey for ' . $path . ', continuing', OutputInterface::VERBOSITY_VERBOSE);
+                        continue;
+                    }
+                    /* If that did not throw and filekey is not empty, a legacy filekey is used */
+                    $clean = false;
+                    $output->writeln($path . ' is using a legacy filekey, migrating');
+                    $this->migrateSinglefile($path, $item, $output);
+                }
+            }
+        }
+
+        return $clean;
+    }
+
+    private function migrateSinglefile(string $path, FileInfo $fileInfo, OutputInterface $output): void {
+        $source = $path;
+        $target = $path . '.reencrypted.' . time();
+
+        try {
+            $this->rootView->copy($source, $target);
+            $copyResource = $this->rootView->fopen($target, 'r');
+            $sourceResource = $this->rootView->fopen($source, 'w');
+            if ($copyResource === false || $sourceResource === false) {
+                throw new DecryptionFailedException('Failed to open ' . $source . ' or ' . $target);
+            }
+            if (stream_copy_to_stream($copyResource, $sourceResource) === false) {
+                $output->writeln('<error>Failed to copy ' . $target . ' data into ' . $source . '</error>');
+                $output->writeln('<error>Leaving both files in there to avoid data loss</error>');
+                return;
+            }
+            $this->rootView->touch($source, $fileInfo->getMTime());
+            $this->rootView->unlink($target);
+            $output->writeln('<info>Migrated ' . $source . '</info>', OutputInterface::VERBOSITY_VERBOSE);
+        } catch (DecryptionFailedException $e) {
+            if ($this->rootView->file_exists($target)) {
+                $this->rootView->unlink($target);
+            }
+            $output->writeln('<error>Failed to migrate ' . $path . '</error>');
+            $output->writeln('<error>' . $e . '</error>', OutputInterface::VERBOSITY_VERBOSE);
+        } finally {
+            if (is_resource($copyResource)) {
+                fclose($copyResource);
+            }
+            if (is_resource($sourceResource)) {
+                fclose($sourceResource);
+            }
+        }
+    }
+
+    /**
+     * setup user file system
+     */
+    protected function setupUserFS(string $uid): void {
+        \OC_Util::tearDownFS();
+        \OC_Util::setupFS($uid);
+    }
 }

Spacing +13 added lines, -13 removed lines

@@ -48,9 +48,9 @@ 
 			do {
 				$users = $backend->getUsers('', $limit, $offset);
 				foreach ($users as $user) {
-					$output->writeln('Scanning all files for ' . $user);
+					$output->writeln('Scanning all files for '.$user);
 					$this->setupUserFS($user);
-					$result = $result && $this->scanFolder($output, '/' . $user);
+					$result = $result && $this->scanFolder($output, '/'.$user);
 				}
 				$offset += $limit;
 			} while (count($users) >= $limit);
@@ -68,7 +68,7 @@ 
 		$clean = true;
 
 		foreach ($this->rootView->getDirectoryContent($folder) as $item) {
-			$path = $folder . '/' . $item['name'];
+			$path = $folder.'/'.$item['name'];
 			if ($this->rootView->is_dir($path)) {
 				if ($this->scanFolder($output, $path) === false) {
 					$clean = false;
@@ -82,21 +82,21 @@ 
 				$stats = $this->rootView->stat($path);
 				if (!isset($stats['hasHeader']) || $stats['hasHeader'] === false) {
 					$clean = false;
-					$output->writeln('<error>' . $path . ' does not have a proper header</error>');
+					$output->writeln('<error>'.$path.' does not have a proper header</error>');
 				} else {
 					try {
 						$legacyFileKey = $this->keyManager->getFileKey($path, true);
 						if ($legacyFileKey === '') {
-							$output->writeln('Got an empty legacy filekey for ' . $path . ', continuing', OutputInterface::VERBOSITY_VERBOSE);
+							$output->writeln('Got an empty legacy filekey for '.$path.', continuing', OutputInterface::VERBOSITY_VERBOSE);
 							continue;
 						}
 					} catch (GenericEncryptionException $e) {
-						$output->writeln('Got a decryption error for legacy filekey for ' . $path . ', continuing', OutputInterface::VERBOSITY_VERBOSE);
+						$output->writeln('Got a decryption error for legacy filekey for '.$path.', continuing', OutputInterface::VERBOSITY_VERBOSE);
 						continue;
 					}
 					/* If that did not throw and filekey is not empty, a legacy filekey is used */
 					$clean = false;
-					$output->writeln($path . ' is using a legacy filekey, migrating');
+					$output->writeln($path.' is using a legacy filekey, migrating');
 					$this->migrateSinglefile($path, $item, $output);
 				}
 			}
@@ -107,29 +107,29 @@ 
 
 	private function migrateSinglefile(string $path, FileInfo $fileInfo, OutputInterface $output): void {
 		$source = $path;
-		$target = $path . '.reencrypted.' . time();
+		$target = $path.'.reencrypted.'.time();
 
 		try {
 			$this->rootView->copy($source, $target);
 			$copyResource = $this->rootView->fopen($target, 'r');
 			$sourceResource = $this->rootView->fopen($source, 'w');
 			if ($copyResource === false || $sourceResource === false) {
-				throw new DecryptionFailedException('Failed to open ' . $source . ' or ' . $target);
+				throw new DecryptionFailedException('Failed to open '.$source.' or '.$target);
 			}
 			if (stream_copy_to_stream($copyResource, $sourceResource) === false) {
-				$output->writeln('<error>Failed to copy ' . $target . ' data into ' . $source . '</error>');
+				$output->writeln('<error>Failed to copy '.$target.' data into '.$source.'</error>');
 				$output->writeln('<error>Leaving both files in there to avoid data loss</error>');
 				return;
 			}
 			$this->rootView->touch($source, $fileInfo->getMTime());
 			$this->rootView->unlink($target);
-			$output->writeln('<info>Migrated ' . $source . '</info>', OutputInterface::VERBOSITY_VERBOSE);
+			$output->writeln('<info>Migrated '.$source.'</info>', OutputInterface::VERBOSITY_VERBOSE);
 		} catch (DecryptionFailedException $e) {
 			if ($this->rootView->file_exists($target)) {
 				$this->rootView->unlink($target);
 			}
-			$output->writeln('<error>Failed to migrate ' . $path . '</error>');
-			$output->writeln('<error>' . $e . '</error>', OutputInterface::VERBOSITY_VERBOSE);
+			$output->writeln('<error>Failed to migrate '.$path.'</error>');
+			$output->writeln('<error>'.$e.'</error>', OutputInterface::VERBOSITY_VERBOSE);
 		} finally {
 			if (is_resource($copyResource)) {
 				fclose($copyResource);

apps/encryption/lib/Recovery.php

Indentation +238 added lines, -238 removed lines

@@ -16,242 +16,242 @@
 use OCP\PreConditionNotMetException;
 
 class Recovery {
-	/**
-	 * @var null|IUser
-	 */
-	protected $user;
-
-	/**
-	 * @param IUserSession $userSession
-	 * @param Crypt $crypt
-	 * @param KeyManager $keyManager
-	 * @param IConfig $config
-	 * @param IFile $file
-	 * @param View $view
-	 */
-	public function __construct(
-		IUserSession $userSession,
-		protected Crypt $crypt,
-		private KeyManager $keyManager,
-		private IConfig $config,
-		private IFile $file,
-		private View $view,
-	) {
-		$this->user = ($userSession->isLoggedIn()) ? $userSession->getUser() : null;
-	}
-
-	/**
-	 * @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
-	 */
-	public function changeRecoveryKeyPassword(string $newPassword, string $oldPassword): bool {
-		$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 !== false) {
-			$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
-	 */
-	private function addRecoveryKeys(string $path): void {
-		$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, null);
-				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());
-
-					$shareKeys = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
-					$this->keyManager->deleteLegacyFileKey($filePath);
-					foreach ($shareKeys as $uid => $keyFile) {
-						$this->keyManager->setShareKey($filePath, $uid, $keyFile);
-					}
-				}
-			}
-		}
-	}
-
-	/**
-	 * remove recovery key to all encrypted files
-	 */
-	private function removeRecoveryKeys(string $path): void {
-		$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
-	 */
-	public function recoverUsersFiles(string $recoveryPassword, string $user): void {
-		$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
-	 */
-	private function recoverAllFiles(string $path, string $privateKey, string $uid): void {
-		$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
-	 */
-	private function recoverFile(string $path, string $privateKey, string $uid): void {
-		$encryptedFileKey = $this->keyManager->getEncryptedFileKey($path);
-		$shareKey = $this->keyManager->getShareKey($path, $this->keyManager->getRecoveryKeyId());
-
-		if ($encryptedFileKey && $shareKey && $privateKey) {
-			$fileKey = $this->crypt->multiKeyDecryptLegacy($encryptedFileKey,
-				$shareKey,
-				$privateKey);
-		} elseif ($shareKey && $privateKey) {
-			$fileKey = $this->crypt->multiKeyDecrypt($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);
-
-			$shareKeys = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
-			$this->keyManager->deleteLegacyFileKey($path);
-			foreach ($shareKeys as $uid => $keyFile) {
-				$this->keyManager->setShareKey($path, $uid, $keyFile);
-			}
-		}
-	}
+    /**
+     * @var null|IUser
+     */
+    protected $user;
+
+    /**
+     * @param IUserSession $userSession
+     * @param Crypt $crypt
+     * @param KeyManager $keyManager
+     * @param IConfig $config
+     * @param IFile $file
+     * @param View $view
+     */
+    public function __construct(
+        IUserSession $userSession,
+        protected Crypt $crypt,
+        private KeyManager $keyManager,
+        private IConfig $config,
+        private IFile $file,
+        private View $view,
+    ) {
+        $this->user = ($userSession->isLoggedIn()) ? $userSession->getUser() : null;
+    }
+
+    /**
+     * @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
+     */
+    public function changeRecoveryKeyPassword(string $newPassword, string $oldPassword): bool {
+        $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 !== false) {
+            $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
+     */
+    private function addRecoveryKeys(string $path): void {
+        $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, null);
+                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());
+
+                    $shareKeys = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
+                    $this->keyManager->deleteLegacyFileKey($filePath);
+                    foreach ($shareKeys as $uid => $keyFile) {
+                        $this->keyManager->setShareKey($filePath, $uid, $keyFile);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * remove recovery key to all encrypted files
+     */
+    private function removeRecoveryKeys(string $path): void {
+        $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
+     */
+    public function recoverUsersFiles(string $recoveryPassword, string $user): void {
+        $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
+     */
+    private function recoverAllFiles(string $path, string $privateKey, string $uid): void {
+        $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
+     */
+    private function recoverFile(string $path, string $privateKey, string $uid): void {
+        $encryptedFileKey = $this->keyManager->getEncryptedFileKey($path);
+        $shareKey = $this->keyManager->getShareKey($path, $this->keyManager->getRecoveryKeyId());
+
+        if ($encryptedFileKey && $shareKey && $privateKey) {
+            $fileKey = $this->crypt->multiKeyDecryptLegacy($encryptedFileKey,
+                $shareKey,
+                $privateKey);
+        } elseif ($shareKey && $privateKey) {
+            $fileKey = $this->crypt->multiKeyDecrypt($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);
+
+            $shareKeys = $this->crypt->multiKeyEncrypt($fileKey, $publicKeys);
+            $this->keyManager->deleteLegacyFileKey($path);
+            foreach ($shareKeys as $uid => $keyFile) {
+                $this->keyManager->setShareKey($path, $uid, $keyFile);
+            }
+        }
+    }
 }

Spacing +7 added lines, -7 removed lines

@@ -77,7 +77,7 @@ 
 		$encryptedRecoveryKey = $this->crypt->encryptPrivateKey($decryptedRecoveryKey, $newPassword);
 		$header = $this->crypt->generateHeader();
 		if ($encryptedRecoveryKey !== false) {
-			$this->keyManager->setSystemPrivateKey($this->keyManager->getRecoveryKeyId(), $header . $encryptedRecoveryKey);
+			$this->keyManager->setSystemPrivateKey($this->keyManager->getRecoveryKeyId(), $header.$encryptedRecoveryKey);
 			return true;
 		}
 		return false;
@@ -138,9 +138,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;
@@ -157,7 +157,7 @@ 
 		foreach ($dirContent as $item) {
 			$filePath = $item->getPath();
 			if ($item['type'] === 'dir') {
-				$this->addRecoveryKeys($filePath . '/');
+				$this->addRecoveryKeys($filePath.'/');
 			} else {
 				$fileKey = $this->keyManager->getFileKey($filePath, null);
 				if (!empty($fileKey)) {
@@ -187,7 +187,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());
 			}
@@ -202,7 +202,7 @@ 
 
 		$privateKey = $this->crypt->decryptPrivateKey($encryptedKey, $recoveryPassword);
 		if ($privateKey !== false) {
-			$this->recoverAllFiles('/' . $user . '/files/', $privateKey, $user);
+			$this->recoverAllFiles('/'.$user.'/files/', $privateKey, $user);
 		}
 	}
 
@@ -216,7 +216,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);
 			}

apps/encryption/lib/Session.php

Indentation +137 added lines, -137 removed lines

@@ -14,141 +14,141 @@
 use OCP\ISession;
 
 class Session {
-	public const NOT_INITIALIZED = '0';
-	public const INIT_EXECUTED = '1';
-	public const INIT_SUCCESSFUL = '2';
-
-	public function __construct(
-		protected ISession $session,
-	) {
-	}
-
-	/**
-	 * Sets status of encryption app
-	 *
-	 * @param string $status INIT_SUCCESSFUL, INIT_EXECUTED, NOT_INITIALIZED
-	 */
-	public function setStatus(string $status): void {
-		$this->session->set('encryptionInitialized', $status);
-	}
-
-	/**
-	 * Gets status if we already tried to initialize the encryption app
-	 *
-	 * @return string init status INIT_SUCCESSFUL, INIT_EXECUTED, NOT_INITIALIZED
-	 */
-	public function getStatus(): string {
-		$status = $this->session->get('encryptionInitialized');
-		if (is_null($status)) {
-			$status = self::NOT_INITIALIZED;
-		}
-
-		return $status;
-	}
-
-	/**
-	 * check if encryption was initialized successfully
-	 */
-	public function isReady(): bool {
-		$status = $this->getStatus();
-		return $status === self::INIT_SUCCESSFUL;
-	}
-
-	/**
-	 * Gets user or public share private key from session
-	 *
-	 * @return string $privateKey The user's plaintext private key
-	 * @throws Exceptions\PrivateKeyMissingException
-	 */
-	public function getPrivateKey(): string {
-		$key = $this->session->get('privateKey');
-		if (is_null($key)) {
-			throw new PrivateKeyMissingException('please try to log-out and log-in again');
-		}
-		return $key;
-	}
-
-	/**
-	 * check if private key is set
-	 */
-	public function isPrivateKeySet(): bool {
-		$key = $this->session->get('privateKey');
-		if (is_null($key)) {
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Sets user private key to session
-	 *
-	 * @param string $key users private key
-	 *
-	 * @note this should only be set on login
-	 */
-	public function setPrivateKey(string $key): void {
-		$this->session->set('privateKey', $key);
-	}
-
-	/**
-	 * store data needed for the decrypt all operation in the session
-	 */
-	public function prepareDecryptAll(string $user, string $key): void {
-		$this->session->set('decryptAll', true);
-		$this->session->set('decryptAllKey', $key);
-		$this->session->set('decryptAllUid', $user);
-	}
-
-	/**
-	 * check if we are in decrypt all mode
-	 */
-	public function decryptAllModeActivated(): bool {
-		$decryptAll = $this->session->get('decryptAll');
-		return ($decryptAll === true);
-	}
-
-	/**
-	 * get uid used for decrypt all operation
-	 *
-	 * @throws \Exception
-	 */
-	public function getDecryptAllUid(): string {
-		$uid = $this->session->get('decryptAllUid');
-		if (is_null($uid) && $this->decryptAllModeActivated()) {
-			throw new \Exception('No uid found while in decrypt all mode');
-		} elseif (is_null($uid)) {
-			throw new \Exception('Please activate decrypt all mode first');
-		}
-
-		return $uid;
-	}
-
-	/**
-	 * get private key for decrypt all operation
-	 *
-	 * @throws PrivateKeyMissingException
-	 */
-	public function getDecryptAllKey(): string {
-		$privateKey = $this->session->get('decryptAllKey');
-		if (is_null($privateKey) && $this->decryptAllModeActivated()) {
-			throw new PrivateKeyMissingException('No private key found while in decrypt all mode');
-		} elseif (is_null($privateKey)) {
-			throw new PrivateKeyMissingException('Please activate decrypt all mode first');
-		}
-
-		return $privateKey;
-	}
-
-	/**
-	 * remove keys from session
-	 */
-	public function clear(): void {
-		$this->session->remove('publicSharePrivateKey');
-		$this->session->remove('privateKey');
-		$this->session->remove('encryptionInitialized');
-		$this->session->remove('decryptAll');
-		$this->session->remove('decryptAllKey');
-		$this->session->remove('decryptAllUid');
-	}
+    public const NOT_INITIALIZED = '0';
+    public const INIT_EXECUTED = '1';
+    public const INIT_SUCCESSFUL = '2';
+
+    public function __construct(
+        protected ISession $session,
+    ) {
+    }
+
+    /**
+     * Sets status of encryption app
+     *
+     * @param string $status INIT_SUCCESSFUL, INIT_EXECUTED, NOT_INITIALIZED
+     */
+    public function setStatus(string $status): void {
+        $this->session->set('encryptionInitialized', $status);
+    }
+
+    /**
+     * Gets status if we already tried to initialize the encryption app
+     *
+     * @return string init status INIT_SUCCESSFUL, INIT_EXECUTED, NOT_INITIALIZED
+     */
+    public function getStatus(): string {
+        $status = $this->session->get('encryptionInitialized');
+        if (is_null($status)) {
+            $status = self::NOT_INITIALIZED;
+        }
+
+        return $status;
+    }
+
+    /**
+     * check if encryption was initialized successfully
+     */
+    public function isReady(): bool {
+        $status = $this->getStatus();
+        return $status === self::INIT_SUCCESSFUL;
+    }
+
+    /**
+     * Gets user or public share private key from session
+     *
+     * @return string $privateKey The user's plaintext private key
+     * @throws Exceptions\PrivateKeyMissingException
+     */
+    public function getPrivateKey(): string {
+        $key = $this->session->get('privateKey');
+        if (is_null($key)) {
+            throw new PrivateKeyMissingException('please try to log-out and log-in again');
+        }
+        return $key;
+    }
+
+    /**
+     * check if private key is set
+     */
+    public function isPrivateKeySet(): bool {
+        $key = $this->session->get('privateKey');
+        if (is_null($key)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Sets user private key to session
+     *
+     * @param string $key users private key
+     *
+     * @note this should only be set on login
+     */
+    public function setPrivateKey(string $key): void {
+        $this->session->set('privateKey', $key);
+    }
+
+    /**
+     * store data needed for the decrypt all operation in the session
+     */
+    public function prepareDecryptAll(string $user, string $key): void {
+        $this->session->set('decryptAll', true);
+        $this->session->set('decryptAllKey', $key);
+        $this->session->set('decryptAllUid', $user);
+    }
+
+    /**
+     * check if we are in decrypt all mode
+     */
+    public function decryptAllModeActivated(): bool {
+        $decryptAll = $this->session->get('decryptAll');
+        return ($decryptAll === true);
+    }
+
+    /**
+     * get uid used for decrypt all operation
+     *
+     * @throws \Exception
+     */
+    public function getDecryptAllUid(): string {
+        $uid = $this->session->get('decryptAllUid');
+        if (is_null($uid) && $this->decryptAllModeActivated()) {
+            throw new \Exception('No uid found while in decrypt all mode');
+        } elseif (is_null($uid)) {
+            throw new \Exception('Please activate decrypt all mode first');
+        }
+
+        return $uid;
+    }
+
+    /**
+     * get private key for decrypt all operation
+     *
+     * @throws PrivateKeyMissingException
+     */
+    public function getDecryptAllKey(): string {
+        $privateKey = $this->session->get('decryptAllKey');
+        if (is_null($privateKey) && $this->decryptAllModeActivated()) {
+            throw new PrivateKeyMissingException('No private key found while in decrypt all mode');
+        } elseif (is_null($privateKey)) {
+            throw new PrivateKeyMissingException('Please activate decrypt all mode first');
+        }
+
+        return $privateKey;
+    }
+
+    /**
+     * remove keys from session
+     */
+    public function clear(): void {
+        $this->session->remove('publicSharePrivateKey');
+        $this->session->remove('privateKey');
+        $this->session->remove('encryptionInitialized');
+        $this->session->remove('decryptAll');
+        $this->session->remove('decryptAllKey');
+        $this->session->remove('decryptAllUid');
+    }
 }

apps/encryption/tests/Crypto/EncryptionTest.php

Indentation +374 added lines, -374 removed lines

@@ -29,378 +29,378 @@
 
 class EncryptionTest extends TestCase {
 
-	protected Encryption $instance;
-
-	protected KeyManager&MockObject $keyManagerMock;
-	protected EncryptAll&MockObject $encryptAllMock;
-	protected DecryptAll&MockObject $decryptAllMock;
-	protected Session&MockObject $sessionMock;
-	protected Crypt&MockObject $cryptMock;
-	protected Util&MockObject $utilMock;
-	protected LoggerInterface&MockObject $loggerMock;
-	protected IL10N&MockObject $l10nMock;
-	protected IStorage&MockObject $storageMock;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->storageMock = $this->getMockBuilder(IStorage::class)
-			->disableOriginalConstructor()->getMock();
-		$this->cryptMock = $this->getMockBuilder(Crypt::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->utilMock = $this->getMockBuilder(Util::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->keyManagerMock = $this->getMockBuilder(KeyManager::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->sessionMock = $this->getMockBuilder(Session::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->encryptAllMock = $this->getMockBuilder(EncryptAll::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->decryptAllMock = $this->getMockBuilder(DecryptAll::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->loggerMock = $this->getMockBuilder(LoggerInterface::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->l10nMock = $this->getMockBuilder(IL10N::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->l10nMock->expects($this->any())
-			->method('t')
-			->with($this->anything())
-			->willReturnArgument(0);
-
-		$this->instance = new Encryption(
-			$this->cryptMock,
-			$this->keyManagerMock,
-			$this->utilMock,
-			$this->sessionMock,
-			$this->encryptAllMock,
-			$this->decryptAllMock,
-			$this->loggerMock,
-			$this->l10nMock
-		);
-	}
-
-	/**
-	 * test if public key from one of the recipients is missing
-	 */
-	public function testEndUser1(): void {
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(false);
-
-		$this->instance->begin('/foo/bar', 'user1', 'r', [], ['users' => ['user1', 'user2', 'user3']]);
-		$this->endTest();
-	}
-
-	/**
-	 * test if public key from owner is missing
-	 *
-	 */
-	public function testEndUser2(): void {
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(false);
-
-		$this->expectException(PublicKeyMissingException::class);
-
-		$this->instance->begin('/foo/bar', 'user2', 'r', [], ['users' => ['user1', 'user2', 'user3']]);
-		$this->endTest();
-	}
-
-	/**
-	 * common part of testEndUser1 and testEndUser2
-	 *
-	 * @throws PublicKeyMissingException
-	 */
-	public function endTest() {
-		// prepare internal variables
-		self::invokePrivate($this->instance, 'isWriteOperation', [true]);
-		self::invokePrivate($this->instance, 'writeCache', ['']);
-
-		$this->keyManagerMock->expects($this->any())
-			->method('getPublicKey')
-			->willReturnCallback([$this, 'getPublicKeyCallback']);
-		$this->keyManagerMock->expects($this->any())
-			->method('addSystemKeys')
-			->willReturnCallback([$this, 'addSystemKeysCallback']);
-		$this->cryptMock->expects($this->any())
-			->method('multiKeyEncrypt')
-			->willReturn([]);
-
-		$this->instance->end('/foo/bar');
-	}
-
-
-	public function getPublicKeyCallback($uid) {
-		if ($uid === 'user2') {
-			throw new PublicKeyMissingException($uid);
-		}
-		return $uid;
-	}
-
-	public function addSystemKeysCallback($accessList, $publicKeys) {
-		$this->assertSame(2, count($publicKeys));
-		$this->assertArrayHasKey('user1', $publicKeys);
-		$this->assertArrayHasKey('user3', $publicKeys);
-		return $publicKeys;
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataProviderForTestGetPathToRealFile')]
-	public function testGetPathToRealFile($path, $expected): void {
-		$this->assertSame($expected,
-			self::invokePrivate($this->instance, 'getPathToRealFile', [$path])
-		);
-	}
-
-	public static function dataProviderForTestGetPathToRealFile(): array {
-		return [
-			['/user/files/foo/bar.txt', '/user/files/foo/bar.txt'],
-			['/user/files/foo.txt', '/user/files/foo.txt'],
-			['/user/files_versions/foo.txt.v543534', '/user/files/foo.txt'],
-			['/user/files_versions/foo/bar.txt.v5454', '/user/files/foo/bar.txt'],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestBegin')]
-	public function testBegin($mode, $header, $legacyCipher, $defaultCipher, $fileKey, $expected): void {
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(false);
-
-		$this->sessionMock->expects($this->never())->method('getDecryptAllUid');
-		$this->sessionMock->expects($this->never())->method('getDecryptAllKey');
-		$this->keyManagerMock->expects($this->never())->method('getEncryptedFileKey');
-		$this->keyManagerMock->expects($this->never())->method('getShareKey');
-		$this->cryptMock->expects($this->never())->method('multiKeyDecrypt');
-
-		$this->cryptMock->expects($this->any())
-			->method('getCipher')
-			->willReturn($defaultCipher);
-		$this->cryptMock->expects($this->any())
-			->method('getLegacyCipher')
-			->willReturn($legacyCipher);
-		if (empty($fileKey)) {
-			$this->cryptMock->expects($this->once())
-				->method('generateFileKey')
-				->willReturn('fileKey');
-		} else {
-			$this->cryptMock->expects($this->never())
-				->method('generateFileKey');
-		}
-
-		$this->keyManagerMock->expects($this->once())
-			->method('getFileKey')
-			->willReturn($fileKey);
-
-		$result = $this->instance->begin('/user/files/foo.txt', 'user', $mode, $header, []);
-
-		$this->assertArrayHasKey('cipher', $result);
-		$this->assertSame($expected, $result['cipher']);
-		if ($mode === 'w') {
-			$this->assertTrue(self::invokePrivate($this->instance, 'isWriteOperation'));
-		} else {
-			$this->assertFalse(self::invokePrivate($this->instance, 'isWriteOperation'));
-		}
-	}
-
-	public static function dataTestBegin(): array {
-		return [
-			['w', ['cipher' => 'myCipher'], 'legacyCipher', 'defaultCipher', 'fileKey', 'defaultCipher'],
-			['r', ['cipher' => 'myCipher'], 'legacyCipher', 'defaultCipher', 'fileKey', 'myCipher'],
-			['w', [], 'legacyCipher', 'defaultCipher', '', 'defaultCipher'],
-			['r', [], 'legacyCipher', 'defaultCipher', 'file_key', 'legacyCipher'],
-		];
-	}
-
-
-	/**
-	 * test begin() if decryptAll mode was activated
-	 */
-	public function testBeginDecryptAll(): void {
-		$path = '/user/files/foo.txt';
-		$fileKey = 'fileKey';
-
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(true);
-		$this->keyManagerMock->expects($this->once())
-			->method('getFileKey')
-			->with($path, null, true)
-			->willReturn($fileKey);
-
-		$this->instance->begin($path, 'user', 'r', [], []);
-
-		$this->assertSame($fileKey,
-			$this->invokePrivate($this->instance, 'fileKey')
-		);
-	}
-
-	/**
-	 * test begin() if encryption is not initialized but the master key is enabled
-	 * in this case we can initialize the encryption without a username/password
-	 * and continue
-	 */
-	public function testBeginInitMasterKey(): void {
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(false);
-
-		$this->sessionMock->expects($this->once())->method('isReady')->willReturn(false);
-		$this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
-		$this->keyManagerMock->expects($this->once())->method('init')->with('', '');
-
-		$this->instance->begin('/user/files/welcome.txt', 'user', 'r', [], []);
-	}
-
-	/**
-	 *
-	 * @param string $fileKey
-	 * @param boolean $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestUpdate')]
-	public function testUpdate($fileKey, $expected): void {
-		$this->keyManagerMock->expects($this->once())
-			->method('getFileKey')->willReturn($fileKey);
-
-		$this->keyManagerMock->expects($this->any())
-			->method('getPublicKey')->willReturn('publicKey');
-
-		$this->keyManagerMock->expects($this->any())
-			->method('addSystemKeys')
-			->willReturnCallback(function ($accessList, $publicKeys) {
-				return $publicKeys;
-			});
-
-		$this->keyManagerMock->expects($this->never())->method('getVersion');
-		$this->keyManagerMock->expects($this->never())->method('setVersion');
-
-		$this->assertSame($expected,
-			$this->instance->update('path', 'user1', ['users' => ['user1']])
-		);
-	}
-
-	public static function dataTestUpdate(): array {
-		return [
-			['', false],
-			['fileKey', true]
-		];
-	}
-
-	public function testUpdateNoUsers(): void {
-		$this->invokePrivate($this->instance, 'rememberVersion', [['path' => 2]]);
-
-		$this->keyManagerMock->expects($this->never())->method('getFileKey');
-		$this->keyManagerMock->expects($this->never())->method('getPublicKey');
-		$this->keyManagerMock->expects($this->never())->method('addSystemKeys');
-		$this->keyManagerMock->expects($this->once())->method('setVersion')
-			->willReturnCallback(function ($path, $version, $view): void {
-				$this->assertSame('path', $path);
-				$this->assertSame(2, $version);
-				$this->assertTrue($view instanceof View);
-			});
-		$this->instance->update('path', 'user1', []);
-	}
-
-	/**
-	 * Test case if the public key is missing. Nextcloud should still encrypt
-	 * the file for the remaining users
-	 */
-	public function testUpdateMissingPublicKey(): void {
-		$this->keyManagerMock->expects($this->once())
-			->method('getFileKey')->willReturn('fileKey');
-
-		$this->keyManagerMock->expects($this->any())
-			->method('getPublicKey')->willReturnCallback(
-				function ($user): void {
-					throw new PublicKeyMissingException($user);
-				}
-			);
-
-		$this->keyManagerMock->expects($this->any())
-			->method('addSystemKeys')
-			->willReturnCallback(function ($accessList, $publicKeys) {
-				return $publicKeys;
-			});
-
-		$this->cryptMock->expects($this->once())->method('multiKeyEncrypt')
-			->willReturnCallback(
-				function ($fileKey, $publicKeys) {
-					$this->assertEmpty($publicKeys);
-					$this->assertSame('fileKey', $fileKey);
-					return [];
-				}
-			);
-
-		$this->keyManagerMock->expects($this->never())->method('getVersion');
-		$this->keyManagerMock->expects($this->never())->method('setVersion');
-
-		$this->assertTrue(
-			$this->instance->update('path', 'user1', ['users' => ['user1']])
-		);
-	}
-
-	/**
-	 * by default the encryption module should encrypt regular files, files in
-	 * files_versions and files in files_trashbin
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestShouldEncrypt')]
-	public function testShouldEncrypt($path, $shouldEncryptHomeStorage, $isHomeStorage, $expected): void {
-		$this->utilMock->expects($this->once())->method('shouldEncryptHomeStorage')
-			->willReturn($shouldEncryptHomeStorage);
-
-		if ($shouldEncryptHomeStorage === false) {
-			$this->storageMock->expects($this->once())->method('instanceOfStorage')
-				->with('\OCP\Files\IHomeStorage')->willReturn($isHomeStorage);
-			$this->utilMock->expects($this->once())->method('getStorage')->with($path)
-				->willReturn($this->storageMock);
-		}
-
-		$this->assertSame($expected,
-			$this->instance->shouldEncrypt($path)
-		);
-	}
-
-	public static function dataTestShouldEncrypt(): array {
-		return [
-			['/user1/files/foo.txt', true, true, true],
-			['/user1/files_versions/foo.txt', true, true, true],
-			['/user1/files_trashbin/foo.txt', true, true, true],
-			['/user1/some_folder/foo.txt', true, true, false],
-			['/user1/foo.txt', true, true, false],
-			['/user1/files', true, true, false],
-			['/user1/files_trashbin', true, true, false],
-			['/user1/files_versions', true, true, false],
-			// test if shouldEncryptHomeStorage is set to false
-			['/user1/files/foo.txt', false, true, false],
-			['/user1/files_versions/foo.txt', false, false, true],
-		];
-	}
-
-
-	public function testDecrypt(): void {
-		$this->expectException(DecryptionFailedException::class);
-		$this->expectExceptionMessage('Cannot decrypt this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
-
-		$this->instance->decrypt('abc');
-	}
-
-	public function testPrepareDecryptAll(): void {
-		/** @var \Symfony\Component\Console\Input\InputInterface $input */
-		$input = $this->createMock(InputInterface::class);
-		/** @var \Symfony\Component\Console\Output\OutputInterface $output */
-		$output = $this->createMock(OutputInterface::class);
-
-		$this->decryptAllMock->expects($this->once())->method('prepare')
-			->with($input, $output, 'user');
-
-		$this->instance->prepareDecryptAll($input, $output, 'user');
-	}
+    protected Encryption $instance;
+
+    protected KeyManager&MockObject $keyManagerMock;
+    protected EncryptAll&MockObject $encryptAllMock;
+    protected DecryptAll&MockObject $decryptAllMock;
+    protected Session&MockObject $sessionMock;
+    protected Crypt&MockObject $cryptMock;
+    protected Util&MockObject $utilMock;
+    protected LoggerInterface&MockObject $loggerMock;
+    protected IL10N&MockObject $l10nMock;
+    protected IStorage&MockObject $storageMock;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->storageMock = $this->getMockBuilder(IStorage::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->cryptMock = $this->getMockBuilder(Crypt::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->utilMock = $this->getMockBuilder(Util::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->keyManagerMock = $this->getMockBuilder(KeyManager::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->sessionMock = $this->getMockBuilder(Session::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->encryptAllMock = $this->getMockBuilder(EncryptAll::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->decryptAllMock = $this->getMockBuilder(DecryptAll::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->loggerMock = $this->getMockBuilder(LoggerInterface::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->l10nMock = $this->getMockBuilder(IL10N::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->l10nMock->expects($this->any())
+            ->method('t')
+            ->with($this->anything())
+            ->willReturnArgument(0);
+
+        $this->instance = new Encryption(
+            $this->cryptMock,
+            $this->keyManagerMock,
+            $this->utilMock,
+            $this->sessionMock,
+            $this->encryptAllMock,
+            $this->decryptAllMock,
+            $this->loggerMock,
+            $this->l10nMock
+        );
+    }
+
+    /**
+     * test if public key from one of the recipients is missing
+     */
+    public function testEndUser1(): void {
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(false);
+
+        $this->instance->begin('/foo/bar', 'user1', 'r', [], ['users' => ['user1', 'user2', 'user3']]);
+        $this->endTest();
+    }
+
+    /**
+     * test if public key from owner is missing
+     *
+     */
+    public function testEndUser2(): void {
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(false);
+
+        $this->expectException(PublicKeyMissingException::class);
+
+        $this->instance->begin('/foo/bar', 'user2', 'r', [], ['users' => ['user1', 'user2', 'user3']]);
+        $this->endTest();
+    }
+
+    /**
+     * common part of testEndUser1 and testEndUser2
+     *
+     * @throws PublicKeyMissingException
+     */
+    public function endTest() {
+        // prepare internal variables
+        self::invokePrivate($this->instance, 'isWriteOperation', [true]);
+        self::invokePrivate($this->instance, 'writeCache', ['']);
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('getPublicKey')
+            ->willReturnCallback([$this, 'getPublicKeyCallback']);
+        $this->keyManagerMock->expects($this->any())
+            ->method('addSystemKeys')
+            ->willReturnCallback([$this, 'addSystemKeysCallback']);
+        $this->cryptMock->expects($this->any())
+            ->method('multiKeyEncrypt')
+            ->willReturn([]);
+
+        $this->instance->end('/foo/bar');
+    }
+
+
+    public function getPublicKeyCallback($uid) {
+        if ($uid === 'user2') {
+            throw new PublicKeyMissingException($uid);
+        }
+        return $uid;
+    }
+
+    public function addSystemKeysCallback($accessList, $publicKeys) {
+        $this->assertSame(2, count($publicKeys));
+        $this->assertArrayHasKey('user1', $publicKeys);
+        $this->assertArrayHasKey('user3', $publicKeys);
+        return $publicKeys;
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataProviderForTestGetPathToRealFile')]
+    public function testGetPathToRealFile($path, $expected): void {
+        $this->assertSame($expected,
+            self::invokePrivate($this->instance, 'getPathToRealFile', [$path])
+        );
+    }
+
+    public static function dataProviderForTestGetPathToRealFile(): array {
+        return [
+            ['/user/files/foo/bar.txt', '/user/files/foo/bar.txt'],
+            ['/user/files/foo.txt', '/user/files/foo.txt'],
+            ['/user/files_versions/foo.txt.v543534', '/user/files/foo.txt'],
+            ['/user/files_versions/foo/bar.txt.v5454', '/user/files/foo/bar.txt'],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestBegin')]
+    public function testBegin($mode, $header, $legacyCipher, $defaultCipher, $fileKey, $expected): void {
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(false);
+
+        $this->sessionMock->expects($this->never())->method('getDecryptAllUid');
+        $this->sessionMock->expects($this->never())->method('getDecryptAllKey');
+        $this->keyManagerMock->expects($this->never())->method('getEncryptedFileKey');
+        $this->keyManagerMock->expects($this->never())->method('getShareKey');
+        $this->cryptMock->expects($this->never())->method('multiKeyDecrypt');
+
+        $this->cryptMock->expects($this->any())
+            ->method('getCipher')
+            ->willReturn($defaultCipher);
+        $this->cryptMock->expects($this->any())
+            ->method('getLegacyCipher')
+            ->willReturn($legacyCipher);
+        if (empty($fileKey)) {
+            $this->cryptMock->expects($this->once())
+                ->method('generateFileKey')
+                ->willReturn('fileKey');
+        } else {
+            $this->cryptMock->expects($this->never())
+                ->method('generateFileKey');
+        }
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('getFileKey')
+            ->willReturn($fileKey);
+
+        $result = $this->instance->begin('/user/files/foo.txt', 'user', $mode, $header, []);
+
+        $this->assertArrayHasKey('cipher', $result);
+        $this->assertSame($expected, $result['cipher']);
+        if ($mode === 'w') {
+            $this->assertTrue(self::invokePrivate($this->instance, 'isWriteOperation'));
+        } else {
+            $this->assertFalse(self::invokePrivate($this->instance, 'isWriteOperation'));
+        }
+    }
+
+    public static function dataTestBegin(): array {
+        return [
+            ['w', ['cipher' => 'myCipher'], 'legacyCipher', 'defaultCipher', 'fileKey', 'defaultCipher'],
+            ['r', ['cipher' => 'myCipher'], 'legacyCipher', 'defaultCipher', 'fileKey', 'myCipher'],
+            ['w', [], 'legacyCipher', 'defaultCipher', '', 'defaultCipher'],
+            ['r', [], 'legacyCipher', 'defaultCipher', 'file_key', 'legacyCipher'],
+        ];
+    }
+
+
+    /**
+     * test begin() if decryptAll mode was activated
+     */
+    public function testBeginDecryptAll(): void {
+        $path = '/user/files/foo.txt';
+        $fileKey = 'fileKey';
+
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(true);
+        $this->keyManagerMock->expects($this->once())
+            ->method('getFileKey')
+            ->with($path, null, true)
+            ->willReturn($fileKey);
+
+        $this->instance->begin($path, 'user', 'r', [], []);
+
+        $this->assertSame($fileKey,
+            $this->invokePrivate($this->instance, 'fileKey')
+        );
+    }
+
+    /**
+     * test begin() if encryption is not initialized but the master key is enabled
+     * in this case we can initialize the encryption without a username/password
+     * and continue
+     */
+    public function testBeginInitMasterKey(): void {
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(false);
+
+        $this->sessionMock->expects($this->once())->method('isReady')->willReturn(false);
+        $this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
+        $this->keyManagerMock->expects($this->once())->method('init')->with('', '');
+
+        $this->instance->begin('/user/files/welcome.txt', 'user', 'r', [], []);
+    }
+
+    /**
+     *
+     * @param string $fileKey
+     * @param boolean $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestUpdate')]
+    public function testUpdate($fileKey, $expected): void {
+        $this->keyManagerMock->expects($this->once())
+            ->method('getFileKey')->willReturn($fileKey);
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('getPublicKey')->willReturn('publicKey');
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('addSystemKeys')
+            ->willReturnCallback(function ($accessList, $publicKeys) {
+                return $publicKeys;
+            });
+
+        $this->keyManagerMock->expects($this->never())->method('getVersion');
+        $this->keyManagerMock->expects($this->never())->method('setVersion');
+
+        $this->assertSame($expected,
+            $this->instance->update('path', 'user1', ['users' => ['user1']])
+        );
+    }
+
+    public static function dataTestUpdate(): array {
+        return [
+            ['', false],
+            ['fileKey', true]
+        ];
+    }
+
+    public function testUpdateNoUsers(): void {
+        $this->invokePrivate($this->instance, 'rememberVersion', [['path' => 2]]);
+
+        $this->keyManagerMock->expects($this->never())->method('getFileKey');
+        $this->keyManagerMock->expects($this->never())->method('getPublicKey');
+        $this->keyManagerMock->expects($this->never())->method('addSystemKeys');
+        $this->keyManagerMock->expects($this->once())->method('setVersion')
+            ->willReturnCallback(function ($path, $version, $view): void {
+                $this->assertSame('path', $path);
+                $this->assertSame(2, $version);
+                $this->assertTrue($view instanceof View);
+            });
+        $this->instance->update('path', 'user1', []);
+    }
+
+    /**
+     * Test case if the public key is missing. Nextcloud should still encrypt
+     * the file for the remaining users
+     */
+    public function testUpdateMissingPublicKey(): void {
+        $this->keyManagerMock->expects($this->once())
+            ->method('getFileKey')->willReturn('fileKey');
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('getPublicKey')->willReturnCallback(
+                function ($user): void {
+                    throw new PublicKeyMissingException($user);
+                }
+            );
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('addSystemKeys')
+            ->willReturnCallback(function ($accessList, $publicKeys) {
+                return $publicKeys;
+            });
+
+        $this->cryptMock->expects($this->once())->method('multiKeyEncrypt')
+            ->willReturnCallback(
+                function ($fileKey, $publicKeys) {
+                    $this->assertEmpty($publicKeys);
+                    $this->assertSame('fileKey', $fileKey);
+                    return [];
+                }
+            );
+
+        $this->keyManagerMock->expects($this->never())->method('getVersion');
+        $this->keyManagerMock->expects($this->never())->method('setVersion');
+
+        $this->assertTrue(
+            $this->instance->update('path', 'user1', ['users' => ['user1']])
+        );
+    }
+
+    /**
+     * by default the encryption module should encrypt regular files, files in
+     * files_versions and files in files_trashbin
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestShouldEncrypt')]
+    public function testShouldEncrypt($path, $shouldEncryptHomeStorage, $isHomeStorage, $expected): void {
+        $this->utilMock->expects($this->once())->method('shouldEncryptHomeStorage')
+            ->willReturn($shouldEncryptHomeStorage);
+
+        if ($shouldEncryptHomeStorage === false) {
+            $this->storageMock->expects($this->once())->method('instanceOfStorage')
+                ->with('\OCP\Files\IHomeStorage')->willReturn($isHomeStorage);
+            $this->utilMock->expects($this->once())->method('getStorage')->with($path)
+                ->willReturn($this->storageMock);
+        }
+
+        $this->assertSame($expected,
+            $this->instance->shouldEncrypt($path)
+        );
+    }
+
+    public static function dataTestShouldEncrypt(): array {
+        return [
+            ['/user1/files/foo.txt', true, true, true],
+            ['/user1/files_versions/foo.txt', true, true, true],
+            ['/user1/files_trashbin/foo.txt', true, true, true],
+            ['/user1/some_folder/foo.txt', true, true, false],
+            ['/user1/foo.txt', true, true, false],
+            ['/user1/files', true, true, false],
+            ['/user1/files_trashbin', true, true, false],
+            ['/user1/files_versions', true, true, false],
+            // test if shouldEncryptHomeStorage is set to false
+            ['/user1/files/foo.txt', false, true, false],
+            ['/user1/files_versions/foo.txt', false, false, true],
+        ];
+    }
+
+
+    public function testDecrypt(): void {
+        $this->expectException(DecryptionFailedException::class);
+        $this->expectExceptionMessage('Cannot decrypt this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
+
+        $this->instance->decrypt('abc');
+    }
+
+    public function testPrepareDecryptAll(): void {
+        /** @var \Symfony\Component\Console\Input\InputInterface $input */
+        $input = $this->createMock(InputInterface::class);
+        /** @var \Symfony\Component\Console\Output\OutputInterface $output */
+        $output = $this->createMock(OutputInterface::class);
+
+        $this->decryptAllMock->expects($this->once())->method('prepare')
+            ->with($input, $output, 'user');
+
+        $this->instance->prepareDecryptAll($input, $output, 'user');
+    }
 }

apps/encryption/tests/RecoveryTest.php

Indentation +265 added lines, -265 removed lines

@@ -22,269 +22,269 @@
 use Test\TestCase;
 
 class RecoveryTest extends TestCase {
-	private static $tempStorage = [];
-
-	private IFile&MockObject $fileMock;
-	private View&MockObject $viewMock;
-	private IUserSession&MockObject $userSessionMock;
-	private IUser&MockObject $user;
-	private KeyManager&MockObject $keyManagerMock;
-	private IConfig&MockObject $configMock;
-	private Crypt&MockObject $cryptMock;
-
-	private Recovery $instance;
-
-	public function testEnableAdminRecoverySuccessful(): void {
-		$this->keyManagerMock->expects($this->exactly(2))
-			->method('recoveryKeyExists')
-			->willReturnOnConsecutiveCalls(false, true);
-
-		$this->cryptMock->expects($this->once())
-			->method('createKeyPair')
-			->willReturn([
-				'publicKey' => 'privateKey',
-				'privateKey' => 'publicKey',
-			]);
-
-		$this->keyManagerMock->expects($this->once())
-			->method('setRecoveryKey')
-			->willReturn(false);
-
-		$this->keyManagerMock->expects($this->exactly(2))
-			->method('checkRecoveryPassword')
-			->willReturnOnConsecutiveCalls(true, true);
-
-		$this->assertTrue($this->instance->enableAdminRecovery('password'));
-		$this->assertArrayHasKey('recoveryAdminEnabled', self::$tempStorage);
-		$this->assertEquals(1, self::$tempStorage['recoveryAdminEnabled']);
-
-		$this->assertTrue($this->instance->enableAdminRecovery('password'));
-	}
-
-	public function testEnableAdminRecoveryCouldNotCheckPassword(): void {
-		$this->keyManagerMock->expects($this->exactly(2))
-			->method('recoveryKeyExists')
-			->willReturnOnConsecutiveCalls(false, true);
-
-		$this->cryptMock->expects($this->once())
-			->method('createKeyPair')
-			->willReturn([
-				'publicKey' => 'privateKey',
-				'privateKey' => 'publicKey',
-			]);
-
-		$this->keyManagerMock->expects($this->once())
-			->method('setRecoveryKey')
-			->willReturn(false);
-
-		$this->keyManagerMock->expects($this->exactly(2))
-			->method('checkRecoveryPassword')
-			->willReturnOnConsecutiveCalls(true, false);
-
-		$this->assertTrue($this->instance->enableAdminRecovery('password'));
-		$this->assertArrayHasKey('recoveryAdminEnabled', self::$tempStorage);
-		$this->assertEquals(1, self::$tempStorage['recoveryAdminEnabled']);
-
-		$this->assertFalse($this->instance->enableAdminRecovery('password'));
-	}
-
-	public function testEnableAdminRecoveryCouldNotCreateKey(): void {
-		$this->keyManagerMock->expects($this->once())
-			->method('recoveryKeyExists')
-			->willReturn(false);
-
-		$this->cryptMock->expects($this->once())
-			->method('createKeyPair')
-			->willReturn(false);
-
-		$this->assertFalse($this->instance->enableAdminRecovery('password'));
-	}
-
-	public function testChangeRecoveryKeyPasswordSuccessful(): void {
-		$this->assertFalse($this->instance->changeRecoveryKeyPassword('password', 'passwordOld'));
-
-		$this->keyManagerMock->expects($this->once())
-			->method('getSystemPrivateKey')
-			->willReturn('privateKey');
-
-		$this->cryptMock->expects($this->once())
-			->method('decryptPrivateKey')
-			->with('privateKey', 'passwordOld')
-			->willReturn('decryptedPrivateKey');
-
-		$this->cryptMock->expects($this->once())
-			->method('encryptPrivateKey')
-			->with('decryptedPrivateKey', 'password')
-			->willReturn('privateKey');
-
-		$this->assertTrue($this->instance->changeRecoveryKeyPassword('password', 'passwordOld'));
-	}
-
-	public function testChangeRecoveryKeyPasswordCouldNotDecryptPrivateRecoveryKey(): void {
-		$this->assertFalse($this->instance->changeRecoveryKeyPassword('password', 'passwordOld'));
-
-		$this->keyManagerMock->expects($this->once())
-			->method('getSystemPrivateKey');
-
-		$this->cryptMock->expects($this->once())
-			->method('decryptPrivateKey')
-			->willReturn(false);
-
-		$this->assertFalse($this->instance->changeRecoveryKeyPassword('password', 'passwordOld'));
-	}
-
-	public function testDisableAdminRecovery(): void {
-		$this->keyManagerMock->expects($this->exactly(2))
-			->method('checkRecoveryPassword')
-			->willReturnOnConsecutiveCalls(true, false);
-
-		$this->assertArrayHasKey('recoveryAdminEnabled', self::$tempStorage);
-		$this->assertTrue($this->instance->disableAdminRecovery('password'));
-		$this->assertEquals(0, self::$tempStorage['recoveryAdminEnabled']);
-
-		$this->assertFalse($this->instance->disableAdminRecovery('password'));
-	}
-
-	public function testIsRecoveryEnabledForUser(): void {
-		$this->configMock->expects($this->exactly(2))
-			->method('getUserValue')
-			->willReturnOnConsecutiveCalls('1', '0');
-
-		$this->assertTrue($this->instance->isRecoveryEnabledForUser());
-		$this->assertFalse($this->instance->isRecoveryEnabledForUser('admin'));
-	}
-
-	public function testIsRecoveryKeyEnabled(): void {
-		$this->assertFalse($this->instance->isRecoveryKeyEnabled());
-		self::$tempStorage['recoveryAdminEnabled'] = '1';
-		$this->assertTrue($this->instance->isRecoveryKeyEnabled());
-	}
-
-	public function testSetRecoveryFolderForUser(): void {
-		$this->viewMock->expects($this->exactly(2))
-			->method('getDirectoryContent')
-			->willReturn([]);
-		$this->assertTrue($this->instance->setRecoveryForUser(0));
-		$this->assertTrue($this->instance->setRecoveryForUser('1'));
-	}
-
-	public function testRecoverUserFiles(): void {
-		$this->viewMock->expects($this->once())
-			->method('getDirectoryContent')
-			->willReturn([]);
-
-		$this->cryptMock->expects($this->once())
-			->method('decryptPrivateKey')
-			->willReturn('privateKey');
-		$this->instance->recoverUsersFiles('password', 'admin');
-		$this->addToAssertionCount(1);
-	}
-
-	public function testRecoverFile(): void {
-		$this->keyManagerMock->expects($this->once())
-			->method('getEncryptedFileKey')
-			->willReturn(true);
-
-		$this->keyManagerMock->expects($this->once())
-			->method('getShareKey')
-			->willReturn(true);
-
-		$this->cryptMock->expects($this->once())
-			->method('multiKeyDecryptLegacy')
-			->willReturn('multiKeyDecryptLegacyResult');
-
-		$this->fileMock->expects($this->once())
-			->method('getAccessList')
-			->willReturn(['users' => ['admin']]);
-
-		$this->keyManagerMock->expects($this->once())
-			->method('getPublicKey')
-			->willReturn('publicKey');
-
-		$this->keyManagerMock->expects($this->once())
-			->method('addSystemKeys')
-			->with($this->anything(), $this->anything(), $this->equalTo('admin'))
-			->willReturn(['admin' => 'publicKey']);
-
-
-		$this->cryptMock->expects($this->once())
-			->method('multiKeyEncrypt')
-			->willReturn(['admin' => 'shareKey']);
-
-		$this->keyManagerMock->expects($this->once())
-			->method('deleteLegacyFileKey');
-		$this->keyManagerMock->expects($this->once())
-			->method('setShareKey');
-
-		$this->assertNull(self::invokePrivate($this->instance,
-			'recoverFile',
-			['/', 'testkey', 'admin']));
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->user = $this->createMock(IUser::class);
-		$this->user->expects($this->any())
-			->method('getUID')
-			->willReturn('admin');
-
-		$this->userSessionMock = $this->createMock(IUserSession::class);
-		$this->userSessionMock->expects($this->any())
-			->method('getUser')
-			->willReturn($this->user);
-		$this->userSessionMock->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-
-		$this->cryptMock = $this->getMockBuilder(Crypt::class)->disableOriginalConstructor()->getMock();
-		$this->keyManagerMock = $this->getMockBuilder(KeyManager::class)->disableOriginalConstructor()->getMock();
-		$this->configMock = $this->createMock(IConfig::class);
-		$this->fileMock = $this->createMock(IFile::class);
-		$this->viewMock = $this->createMock(View::class);
-
-		$this->configMock->expects($this->any())
-			->method('setAppValue')
-			->willReturnCallback([$this, 'setValueTester']);
-
-		$this->configMock->expects($this->any())
-			->method('getAppValue')
-			->willReturnCallback([$this, 'getValueTester']);
-
-		$this->instance = new Recovery($this->userSessionMock,
-			$this->cryptMock,
-			$this->keyManagerMock,
-			$this->configMock,
-			$this->fileMock,
-			$this->viewMock);
-	}
-
-
-	/**
-	 * @param $app
-	 * @param $key
-	 * @param $value
-	 */
-	public function setValueTester($app, $key, $value) {
-		self::$tempStorage[$key] = $value;
-	}
-
-	/**
-	 * @param $key
-	 */
-	public function removeValueTester($key) {
-		unset(self::$tempStorage[$key]);
-	}
-
-	/**
-	 * @param $app
-	 * @param $key
-	 * @return mixed
-	 */
-	public function getValueTester($app, $key) {
-		if (!empty(self::$tempStorage[$key])) {
-			return self::$tempStorage[$key];
-		}
-		return null;
-	}
+    private static $tempStorage = [];
+
+    private IFile&MockObject $fileMock;
+    private View&MockObject $viewMock;
+    private IUserSession&MockObject $userSessionMock;
+    private IUser&MockObject $user;
+    private KeyManager&MockObject $keyManagerMock;
+    private IConfig&MockObject $configMock;
+    private Crypt&MockObject $cryptMock;
+
+    private Recovery $instance;
+
+    public function testEnableAdminRecoverySuccessful(): void {
+        $this->keyManagerMock->expects($this->exactly(2))
+            ->method('recoveryKeyExists')
+            ->willReturnOnConsecutiveCalls(false, true);
+
+        $this->cryptMock->expects($this->once())
+            ->method('createKeyPair')
+            ->willReturn([
+                'publicKey' => 'privateKey',
+                'privateKey' => 'publicKey',
+            ]);
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('setRecoveryKey')
+            ->willReturn(false);
+
+        $this->keyManagerMock->expects($this->exactly(2))
+            ->method('checkRecoveryPassword')
+            ->willReturnOnConsecutiveCalls(true, true);
+
+        $this->assertTrue($this->instance->enableAdminRecovery('password'));
+        $this->assertArrayHasKey('recoveryAdminEnabled', self::$tempStorage);
+        $this->assertEquals(1, self::$tempStorage['recoveryAdminEnabled']);
+
+        $this->assertTrue($this->instance->enableAdminRecovery('password'));
+    }
+
+    public function testEnableAdminRecoveryCouldNotCheckPassword(): void {
+        $this->keyManagerMock->expects($this->exactly(2))
+            ->method('recoveryKeyExists')
+            ->willReturnOnConsecutiveCalls(false, true);
+
+        $this->cryptMock->expects($this->once())
+            ->method('createKeyPair')
+            ->willReturn([
+                'publicKey' => 'privateKey',
+                'privateKey' => 'publicKey',
+            ]);
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('setRecoveryKey')
+            ->willReturn(false);
+
+        $this->keyManagerMock->expects($this->exactly(2))
+            ->method('checkRecoveryPassword')
+            ->willReturnOnConsecutiveCalls(true, false);
+
+        $this->assertTrue($this->instance->enableAdminRecovery('password'));
+        $this->assertArrayHasKey('recoveryAdminEnabled', self::$tempStorage);
+        $this->assertEquals(1, self::$tempStorage['recoveryAdminEnabled']);
+
+        $this->assertFalse($this->instance->enableAdminRecovery('password'));
+    }
+
+    public function testEnableAdminRecoveryCouldNotCreateKey(): void {
+        $this->keyManagerMock->expects($this->once())
+            ->method('recoveryKeyExists')
+            ->willReturn(false);
+
+        $this->cryptMock->expects($this->once())
+            ->method('createKeyPair')
+            ->willReturn(false);
+
+        $this->assertFalse($this->instance->enableAdminRecovery('password'));
+    }
+
+    public function testChangeRecoveryKeyPasswordSuccessful(): void {
+        $this->assertFalse($this->instance->changeRecoveryKeyPassword('password', 'passwordOld'));
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('getSystemPrivateKey')
+            ->willReturn('privateKey');
+
+        $this->cryptMock->expects($this->once())
+            ->method('decryptPrivateKey')
+            ->with('privateKey', 'passwordOld')
+            ->willReturn('decryptedPrivateKey');
+
+        $this->cryptMock->expects($this->once())
+            ->method('encryptPrivateKey')
+            ->with('decryptedPrivateKey', 'password')
+            ->willReturn('privateKey');
+
+        $this->assertTrue($this->instance->changeRecoveryKeyPassword('password', 'passwordOld'));
+    }
+
+    public function testChangeRecoveryKeyPasswordCouldNotDecryptPrivateRecoveryKey(): void {
+        $this->assertFalse($this->instance->changeRecoveryKeyPassword('password', 'passwordOld'));
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('getSystemPrivateKey');
+
+        $this->cryptMock->expects($this->once())
+            ->method('decryptPrivateKey')
+            ->willReturn(false);
+
+        $this->assertFalse($this->instance->changeRecoveryKeyPassword('password', 'passwordOld'));
+    }
+
+    public function testDisableAdminRecovery(): void {
+        $this->keyManagerMock->expects($this->exactly(2))
+            ->method('checkRecoveryPassword')
+            ->willReturnOnConsecutiveCalls(true, false);
+
+        $this->assertArrayHasKey('recoveryAdminEnabled', self::$tempStorage);
+        $this->assertTrue($this->instance->disableAdminRecovery('password'));
+        $this->assertEquals(0, self::$tempStorage['recoveryAdminEnabled']);
+
+        $this->assertFalse($this->instance->disableAdminRecovery('password'));
+    }
+
+    public function testIsRecoveryEnabledForUser(): void {
+        $this->configMock->expects($this->exactly(2))
+            ->method('getUserValue')
+            ->willReturnOnConsecutiveCalls('1', '0');
+
+        $this->assertTrue($this->instance->isRecoveryEnabledForUser());
+        $this->assertFalse($this->instance->isRecoveryEnabledForUser('admin'));
+    }
+
+    public function testIsRecoveryKeyEnabled(): void {
+        $this->assertFalse($this->instance->isRecoveryKeyEnabled());
+        self::$tempStorage['recoveryAdminEnabled'] = '1';
+        $this->assertTrue($this->instance->isRecoveryKeyEnabled());
+    }
+
+    public function testSetRecoveryFolderForUser(): void {
+        $this->viewMock->expects($this->exactly(2))
+            ->method('getDirectoryContent')
+            ->willReturn([]);
+        $this->assertTrue($this->instance->setRecoveryForUser(0));
+        $this->assertTrue($this->instance->setRecoveryForUser('1'));
+    }
+
+    public function testRecoverUserFiles(): void {
+        $this->viewMock->expects($this->once())
+            ->method('getDirectoryContent')
+            ->willReturn([]);
+
+        $this->cryptMock->expects($this->once())
+            ->method('decryptPrivateKey')
+            ->willReturn('privateKey');
+        $this->instance->recoverUsersFiles('password', 'admin');
+        $this->addToAssertionCount(1);
+    }
+
+    public function testRecoverFile(): void {
+        $this->keyManagerMock->expects($this->once())
+            ->method('getEncryptedFileKey')
+            ->willReturn(true);
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('getShareKey')
+            ->willReturn(true);
+
+        $this->cryptMock->expects($this->once())
+            ->method('multiKeyDecryptLegacy')
+            ->willReturn('multiKeyDecryptLegacyResult');
+
+        $this->fileMock->expects($this->once())
+            ->method('getAccessList')
+            ->willReturn(['users' => ['admin']]);
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('getPublicKey')
+            ->willReturn('publicKey');
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('addSystemKeys')
+            ->with($this->anything(), $this->anything(), $this->equalTo('admin'))
+            ->willReturn(['admin' => 'publicKey']);
+
+
+        $this->cryptMock->expects($this->once())
+            ->method('multiKeyEncrypt')
+            ->willReturn(['admin' => 'shareKey']);
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('deleteLegacyFileKey');
+        $this->keyManagerMock->expects($this->once())
+            ->method('setShareKey');
+
+        $this->assertNull(self::invokePrivate($this->instance,
+            'recoverFile',
+            ['/', 'testkey', 'admin']));
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->user = $this->createMock(IUser::class);
+        $this->user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('admin');
+
+        $this->userSessionMock = $this->createMock(IUserSession::class);
+        $this->userSessionMock->expects($this->any())
+            ->method('getUser')
+            ->willReturn($this->user);
+        $this->userSessionMock->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+
+        $this->cryptMock = $this->getMockBuilder(Crypt::class)->disableOriginalConstructor()->getMock();
+        $this->keyManagerMock = $this->getMockBuilder(KeyManager::class)->disableOriginalConstructor()->getMock();
+        $this->configMock = $this->createMock(IConfig::class);
+        $this->fileMock = $this->createMock(IFile::class);
+        $this->viewMock = $this->createMock(View::class);
+
+        $this->configMock->expects($this->any())
+            ->method('setAppValue')
+            ->willReturnCallback([$this, 'setValueTester']);
+
+        $this->configMock->expects($this->any())
+            ->method('getAppValue')
+            ->willReturnCallback([$this, 'getValueTester']);
+
+        $this->instance = new Recovery($this->userSessionMock,
+            $this->cryptMock,
+            $this->keyManagerMock,
+            $this->configMock,
+            $this->fileMock,
+            $this->viewMock);
+    }
+
+
+    /**
+     * @param $app
+     * @param $key
+     * @param $value
+     */
+    public function setValueTester($app, $key, $value) {
+        self::$tempStorage[$key] = $value;
+    }
+
+    /**
+     * @param $key
+     */
+    public function removeValueTester($key) {
+        unset(self::$tempStorage[$key]);
+    }
+
+    /**
+     * @param $app
+     * @param $key
+     * @return mixed
+     */
+    public function getValueTester($app, $key) {
+        if (!empty(self::$tempStorage[$key])) {
+            return self::$tempStorage[$key];
+        }
+        return null;
+    }
 }

apps/encryption/tests/SessionTest.php

Indentation +186 added lines, -186 removed lines

@@ -16,190 +16,190 @@
 use Test\TestCase;
 
 class SessionTest extends TestCase {
-	private static $tempStorage = [];
-
-	protected Session $instance;
-	protected ISession&MockObject $sessionMock;
-
-	public function testThatGetPrivateKeyThrowsExceptionWhenNotSet(): void {
-		$this->expectException(PrivateKeyMissingException::class);
-		$this->expectExceptionMessage('Private Key missing for user: please try to log-out and log-in again');
-
-		$this->instance->getPrivateKey();
-	}
-
-	/**
-	 * @depends testThatGetPrivateKeyThrowsExceptionWhenNotSet
-	 */
-	public function testSetAndGetPrivateKey(): void {
-		$this->instance->setPrivateKey('dummyPrivateKey');
-		$this->assertEquals('dummyPrivateKey', $this->instance->getPrivateKey());
-	}
-
-	/**
-	 * @depends testSetAndGetPrivateKey
-	 */
-	public function testIsPrivateKeySet(): void {
-		$this->instance->setPrivateKey('dummyPrivateKey');
-		$this->assertTrue($this->instance->isPrivateKeySet());
-
-		unset(self::$tempStorage['privateKey']);
-		$this->assertFalse($this->instance->isPrivateKeySet());
-
-		// Set private key back so we can test clear method
-		self::$tempStorage['privateKey'] = 'dummyPrivateKey';
-	}
-
-	public function testDecryptAllModeActivated(): void {
-		$this->instance->prepareDecryptAll('user1', 'usersKey');
-		$this->assertTrue($this->instance->decryptAllModeActivated());
-		$this->assertSame('user1', $this->instance->getDecryptAllUid());
-		$this->assertSame('usersKey', $this->instance->getDecryptAllKey());
-	}
-
-	public function testDecryptAllModeDeactivated(): void {
-		$this->assertFalse($this->instance->decryptAllModeActivated());
-	}
-
-	/**
-	 * @expectExceptionMessage 'Please activate decrypt all mode first'
-	 */
-	public function testGetDecryptAllUidException(): void {
-		$this->expectException(\Exception::class);
-
-		$this->instance->getDecryptAllUid();
-	}
-
-	/**
-	 * @expectExceptionMessage 'No uid found while in decrypt all mode'
-	 */
-	public function testGetDecryptAllUidException2(): void {
-		$this->expectException(\Exception::class);
-
-		$this->instance->prepareDecryptAll('', 'key');
-		$this->instance->getDecryptAllUid();
-	}
-
-	/**
-	 * @expectExceptionMessage 'Please activate decrypt all mode first'
-	 */
-	public function testGetDecryptAllKeyException(): void {
-		$this->expectException(PrivateKeyMissingException::class);
-
-		$this->instance->getDecryptAllKey();
-	}
-
-	/**
-	 * @expectExceptionMessage 'No key found while in decrypt all mode'
-	 */
-	public function testGetDecryptAllKeyException2(): void {
-		$this->expectException(PrivateKeyMissingException::class);
-
-		$this->instance->prepareDecryptAll('user', '');
-		$this->instance->getDecryptAllKey();
-	}
-
-
-	public function testSetAndGetStatusWillSetAndReturn(): void {
-		// Check if get status will return 0 if it has not been set before
-		$this->assertEquals(0, $this->instance->getStatus());
-
-		$this->instance->setStatus(Session::NOT_INITIALIZED);
-		$this->assertEquals(0, $this->instance->getStatus());
-
-		$this->instance->setStatus(Session::INIT_EXECUTED);
-		$this->assertEquals(1, $this->instance->getStatus());
-
-		$this->instance->setStatus(Session::INIT_SUCCESSFUL);
-		$this->assertEquals(2, $this->instance->getStatus());
-	}
-
-	/**
-	 *
-	 * @param int $status
-	 * @param bool $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestIsReady')]
-	public function testIsReady($status, $expected): void {
-		/** @var Session&MockObject $instance */
-		$instance = $this->getMockBuilder(Session::class)
-			->setConstructorArgs([$this->sessionMock])
-			->onlyMethods(['getStatus'])
-			->getMock();
-
-		$instance->expects($this->once())->method('getStatus')
-			->willReturn($status);
-
-		$this->assertSame($expected, $instance->isReady());
-	}
-
-	public static function dataTestIsReady(): array {
-		return [
-			[Session::INIT_SUCCESSFUL, true],
-			[Session::INIT_EXECUTED, false],
-			[Session::NOT_INITIALIZED, false],
-		];
-	}
-
-	/**
-	 * @param $key
-	 * @param $value
-	 */
-	public function setValueTester($key, $value) {
-		self::$tempStorage[$key] = $value;
-	}
-
-	/**
-	 * @param $key
-	 */
-	public function removeValueTester($key) {
-		unset(self::$tempStorage[$key]);
-	}
-
-	/**
-	 * @param $key
-	 * @return mixed
-	 */
-	public function getValueTester($key) {
-		if (!empty(self::$tempStorage[$key])) {
-			return self::$tempStorage[$key];
-		}
-		return null;
-	}
-
-
-	public function testClearWillRemoveValues(): void {
-		$this->instance->setPrivateKey('privateKey');
-		$this->instance->setStatus('initStatus');
-		$this->instance->prepareDecryptAll('user', 'key');
-		$this->assertNotEmpty(self::$tempStorage);
-		$this->instance->clear();
-		$this->assertEmpty(self::$tempStorage);
-	}
-
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->sessionMock = $this->createMock(ISession::class);
-
-		$this->sessionMock->expects($this->any())
-			->method('set')
-			->willReturnCallback([$this, 'setValueTester']);
-
-		$this->sessionMock->expects($this->any())
-			->method('get')
-			->willReturnCallback([$this, 'getValueTester']);
-
-		$this->sessionMock->expects($this->any())
-			->method('remove')
-			->willReturnCallback([$this, 'removeValueTester']);
-
-
-		$this->instance = new Session($this->sessionMock);
-	}
-
-	protected function tearDown(): void {
-		self::$tempStorage = [];
-		parent::tearDown();
-	}
+    private static $tempStorage = [];
+
+    protected Session $instance;
+    protected ISession&MockObject $sessionMock;
+
+    public function testThatGetPrivateKeyThrowsExceptionWhenNotSet(): void {
+        $this->expectException(PrivateKeyMissingException::class);
+        $this->expectExceptionMessage('Private Key missing for user: please try to log-out and log-in again');
+
+        $this->instance->getPrivateKey();
+    }
+
+    /**
+     * @depends testThatGetPrivateKeyThrowsExceptionWhenNotSet
+     */
+    public function testSetAndGetPrivateKey(): void {
+        $this->instance->setPrivateKey('dummyPrivateKey');
+        $this->assertEquals('dummyPrivateKey', $this->instance->getPrivateKey());
+    }
+
+    /**
+     * @depends testSetAndGetPrivateKey
+     */
+    public function testIsPrivateKeySet(): void {
+        $this->instance->setPrivateKey('dummyPrivateKey');
+        $this->assertTrue($this->instance->isPrivateKeySet());
+
+        unset(self::$tempStorage['privateKey']);
+        $this->assertFalse($this->instance->isPrivateKeySet());
+
+        // Set private key back so we can test clear method
+        self::$tempStorage['privateKey'] = 'dummyPrivateKey';
+    }
+
+    public function testDecryptAllModeActivated(): void {
+        $this->instance->prepareDecryptAll('user1', 'usersKey');
+        $this->assertTrue($this->instance->decryptAllModeActivated());
+        $this->assertSame('user1', $this->instance->getDecryptAllUid());
+        $this->assertSame('usersKey', $this->instance->getDecryptAllKey());
+    }
+
+    public function testDecryptAllModeDeactivated(): void {
+        $this->assertFalse($this->instance->decryptAllModeActivated());
+    }
+
+    /**
+     * @expectExceptionMessage 'Please activate decrypt all mode first'
+     */
+    public function testGetDecryptAllUidException(): void {
+        $this->expectException(\Exception::class);
+
+        $this->instance->getDecryptAllUid();
+    }
+
+    /**
+     * @expectExceptionMessage 'No uid found while in decrypt all mode'
+     */
+    public function testGetDecryptAllUidException2(): void {
+        $this->expectException(\Exception::class);
+
+        $this->instance->prepareDecryptAll('', 'key');
+        $this->instance->getDecryptAllUid();
+    }
+
+    /**
+     * @expectExceptionMessage 'Please activate decrypt all mode first'
+     */
+    public function testGetDecryptAllKeyException(): void {
+        $this->expectException(PrivateKeyMissingException::class);
+
+        $this->instance->getDecryptAllKey();
+    }
+
+    /**
+     * @expectExceptionMessage 'No key found while in decrypt all mode'
+     */
+    public function testGetDecryptAllKeyException2(): void {
+        $this->expectException(PrivateKeyMissingException::class);
+
+        $this->instance->prepareDecryptAll('user', '');
+        $this->instance->getDecryptAllKey();
+    }
+
+
+    public function testSetAndGetStatusWillSetAndReturn(): void {
+        // Check if get status will return 0 if it has not been set before
+        $this->assertEquals(0, $this->instance->getStatus());
+
+        $this->instance->setStatus(Session::NOT_INITIALIZED);
+        $this->assertEquals(0, $this->instance->getStatus());
+
+        $this->instance->setStatus(Session::INIT_EXECUTED);
+        $this->assertEquals(1, $this->instance->getStatus());
+
+        $this->instance->setStatus(Session::INIT_SUCCESSFUL);
+        $this->assertEquals(2, $this->instance->getStatus());
+    }
+
+    /**
+     *
+     * @param int $status
+     * @param bool $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestIsReady')]
+    public function testIsReady($status, $expected): void {
+        /** @var Session&MockObject $instance */
+        $instance = $this->getMockBuilder(Session::class)
+            ->setConstructorArgs([$this->sessionMock])
+            ->onlyMethods(['getStatus'])
+            ->getMock();
+
+        $instance->expects($this->once())->method('getStatus')
+            ->willReturn($status);
+
+        $this->assertSame($expected, $instance->isReady());
+    }
+
+    public static function dataTestIsReady(): array {
+        return [
+            [Session::INIT_SUCCESSFUL, true],
+            [Session::INIT_EXECUTED, false],
+            [Session::NOT_INITIALIZED, false],
+        ];
+    }
+
+    /**
+     * @param $key
+     * @param $value
+     */
+    public function setValueTester($key, $value) {
+        self::$tempStorage[$key] = $value;
+    }
+
+    /**
+     * @param $key
+     */
+    public function removeValueTester($key) {
+        unset(self::$tempStorage[$key]);
+    }
+
+    /**
+     * @param $key
+     * @return mixed
+     */
+    public function getValueTester($key) {
+        if (!empty(self::$tempStorage[$key])) {
+            return self::$tempStorage[$key];
+        }
+        return null;
+    }
+
+
+    public function testClearWillRemoveValues(): void {
+        $this->instance->setPrivateKey('privateKey');
+        $this->instance->setStatus('initStatus');
+        $this->instance->prepareDecryptAll('user', 'key');
+        $this->assertNotEmpty(self::$tempStorage);
+        $this->instance->clear();
+        $this->assertEmpty(self::$tempStorage);
+    }
+
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->sessionMock = $this->createMock(ISession::class);
+
+        $this->sessionMock->expects($this->any())
+            ->method('set')
+            ->willReturnCallback([$this, 'setValueTester']);
+
+        $this->sessionMock->expects($this->any())
+            ->method('get')
+            ->willReturnCallback([$this, 'getValueTester']);
+
+        $this->sessionMock->expects($this->any())
+            ->method('remove')
+            ->willReturnCallback([$this, 'removeValueTester']);
+
+
+        $this->instance = new Session($this->sessionMock);
+    }
+
+    protected function tearDown(): void {
+        self::$tempStorage = [];
+        parent::tearDown();
+    }
 }

apps/encryption/tests/Controller/RecoveryControllerTest.php

Indentation +137 added lines, -137 removed lines

@@ -19,141 +19,141 @@
 use Test\TestCase;
 
 class RecoveryControllerTest extends TestCase {
-	protected RecoveryController $controller;
-
-	protected IRequest&MockObject $requestMock;
-	protected IConfig&MockObject $configMock;
-	protected IL10N&MockObject $l10nMock;
-	protected Recovery&MockObject $recoveryMock;
-
-	public static function adminRecoveryProvider(): array {
-		return [
-			['test', 'test', '1', 'Recovery key successfully enabled', Http::STATUS_OK],
-			['', 'test', '1', 'Missing recovery key password', Http::STATUS_BAD_REQUEST],
-			['test', '', '1', 'Please repeat the recovery key password', Http::STATUS_BAD_REQUEST],
-			['test', 'something that doesn\'t match', '1', 'Repeated recovery key password does not match the provided recovery key password', Http::STATUS_BAD_REQUEST],
-			['test', 'test', '0', 'Recovery key successfully disabled', Http::STATUS_OK],
-		];
-	}
-
-	/**
-	 * @param $recoveryPassword
-	 * @param $passConfirm
-	 * @param $enableRecovery
-	 * @param $expectedMessage
-	 * @param $expectedStatus
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('adminRecoveryProvider')]
-	public function testAdminRecovery($recoveryPassword, $passConfirm, $enableRecovery, $expectedMessage, $expectedStatus): void {
-		$this->recoveryMock->expects($this->any())
-			->method('enableAdminRecovery')
-			->willReturn(true);
-
-		$this->recoveryMock->expects($this->any())
-			->method('disableAdminRecovery')
-			->willReturn(true);
-
-		$response = $this->controller->adminRecovery($recoveryPassword,
-			$passConfirm,
-			$enableRecovery);
-
-
-		$this->assertEquals($expectedMessage, $response->getData()['data']['message']);
-		$this->assertEquals($expectedStatus, $response->getStatus());
-	}
-
-	public static function changeRecoveryPasswordProvider(): array {
-		return [
-			['test', 'test', 'oldtestFail', 'Could not change the password. Maybe the old password was not correct.', Http::STATUS_BAD_REQUEST],
-			['test', 'test', 'oldtest', 'Password successfully changed.', Http::STATUS_OK],
-			['test', 'notmatch', 'oldtest', 'Repeated recovery key password does not match the provided recovery key password', Http::STATUS_BAD_REQUEST],
-			['', 'test', 'oldtest', 'Please provide a new recovery password', Http::STATUS_BAD_REQUEST],
-			['test', 'test', '', 'Please provide the old recovery password', Http::STATUS_BAD_REQUEST]
-		];
-	}
-
-	/**
-	 * @param $password
-	 * @param $confirmPassword
-	 * @param $oldPassword
-	 * @param $expectedMessage
-	 * @param $expectedStatus
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('changeRecoveryPasswordProvider')]
-	public function testChangeRecoveryPassword($password, $confirmPassword, $oldPassword, $expectedMessage, $expectedStatus): void {
-		$this->recoveryMock->expects($this->any())
-			->method('changeRecoveryKeyPassword')
-			->with($password, $oldPassword)
-			->willReturnMap([
-				['test', 'oldtestFail', false],
-				['test', 'oldtest', true]
-			]);
-
-		$response = $this->controller->changeRecoveryPassword($password,
-			$oldPassword,
-			$confirmPassword);
-
-		$this->assertEquals($expectedMessage, $response->getData()['data']['message']);
-		$this->assertEquals($expectedStatus, $response->getStatus());
-	}
-
-	public static function userSetRecoveryProvider(): array {
-		return [
-			['1', 'Recovery Key enabled', Http::STATUS_OK],
-			['0', 'Could not enable the recovery key, please try again or contact your administrator', Http::STATUS_BAD_REQUEST]
-		];
-	}
-
-	/**
-	 * @param $enableRecovery
-	 * @param $expectedMessage
-	 * @param $expectedStatus
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('userSetRecoveryProvider')]
-	public function testUserSetRecovery($enableRecovery, $expectedMessage, $expectedStatus): void {
-		$this->recoveryMock->expects($this->any())
-			->method('setRecoveryForUser')
-			->with($enableRecovery)
-			->willReturnMap([
-				['1', true],
-				['0', false]
-			]);
-
-
-		$response = $this->controller->userSetRecovery($enableRecovery);
-
-		$this->assertEquals($expectedMessage, $response->getData()['data']['message']);
-		$this->assertEquals($expectedStatus, $response->getStatus());
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->requestMock = $this->getMockBuilder(IRequest::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->configMock = $this->getMockBuilder(IConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->l10nMock = $this->getMockBuilder(IL10N::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		// Make l10n work in our tests
-		$this->l10nMock->expects($this->any())
-			->method('t')
-			->willReturnArgument(0);
-
-		$this->recoveryMock = $this->getMockBuilder(Recovery::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->controller = new RecoveryController('encryption',
-			$this->requestMock,
-			$this->configMock,
-			$this->l10nMock,
-			$this->recoveryMock);
-	}
+    protected RecoveryController $controller;
+
+    protected IRequest&MockObject $requestMock;
+    protected IConfig&MockObject $configMock;
+    protected IL10N&MockObject $l10nMock;
+    protected Recovery&MockObject $recoveryMock;
+
+    public static function adminRecoveryProvider(): array {
+        return [
+            ['test', 'test', '1', 'Recovery key successfully enabled', Http::STATUS_OK],
+            ['', 'test', '1', 'Missing recovery key password', Http::STATUS_BAD_REQUEST],
+            ['test', '', '1', 'Please repeat the recovery key password', Http::STATUS_BAD_REQUEST],
+            ['test', 'something that doesn\'t match', '1', 'Repeated recovery key password does not match the provided recovery key password', Http::STATUS_BAD_REQUEST],
+            ['test', 'test', '0', 'Recovery key successfully disabled', Http::STATUS_OK],
+        ];
+    }
+
+    /**
+     * @param $recoveryPassword
+     * @param $passConfirm
+     * @param $enableRecovery
+     * @param $expectedMessage
+     * @param $expectedStatus
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('adminRecoveryProvider')]
+    public function testAdminRecovery($recoveryPassword, $passConfirm, $enableRecovery, $expectedMessage, $expectedStatus): void {
+        $this->recoveryMock->expects($this->any())
+            ->method('enableAdminRecovery')
+            ->willReturn(true);
+
+        $this->recoveryMock->expects($this->any())
+            ->method('disableAdminRecovery')
+            ->willReturn(true);
+
+        $response = $this->controller->adminRecovery($recoveryPassword,
+            $passConfirm,
+            $enableRecovery);
+
+
+        $this->assertEquals($expectedMessage, $response->getData()['data']['message']);
+        $this->assertEquals($expectedStatus, $response->getStatus());
+    }
+
+    public static function changeRecoveryPasswordProvider(): array {
+        return [
+            ['test', 'test', 'oldtestFail', 'Could not change the password. Maybe the old password was not correct.', Http::STATUS_BAD_REQUEST],
+            ['test', 'test', 'oldtest', 'Password successfully changed.', Http::STATUS_OK],
+            ['test', 'notmatch', 'oldtest', 'Repeated recovery key password does not match the provided recovery key password', Http::STATUS_BAD_REQUEST],
+            ['', 'test', 'oldtest', 'Please provide a new recovery password', Http::STATUS_BAD_REQUEST],
+            ['test', 'test', '', 'Please provide the old recovery password', Http::STATUS_BAD_REQUEST]
+        ];
+    }
+
+    /**
+     * @param $password
+     * @param $confirmPassword
+     * @param $oldPassword
+     * @param $expectedMessage
+     * @param $expectedStatus
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('changeRecoveryPasswordProvider')]
+    public function testChangeRecoveryPassword($password, $confirmPassword, $oldPassword, $expectedMessage, $expectedStatus): void {
+        $this->recoveryMock->expects($this->any())
+            ->method('changeRecoveryKeyPassword')
+            ->with($password, $oldPassword)
+            ->willReturnMap([
+                ['test', 'oldtestFail', false],
+                ['test', 'oldtest', true]
+            ]);
+
+        $response = $this->controller->changeRecoveryPassword($password,
+            $oldPassword,
+            $confirmPassword);
+
+        $this->assertEquals($expectedMessage, $response->getData()['data']['message']);
+        $this->assertEquals($expectedStatus, $response->getStatus());
+    }
+
+    public static function userSetRecoveryProvider(): array {
+        return [
+            ['1', 'Recovery Key enabled', Http::STATUS_OK],
+            ['0', 'Could not enable the recovery key, please try again or contact your administrator', Http::STATUS_BAD_REQUEST]
+        ];
+    }
+
+    /**
+     * @param $enableRecovery
+     * @param $expectedMessage
+     * @param $expectedStatus
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('userSetRecoveryProvider')]
+    public function testUserSetRecovery($enableRecovery, $expectedMessage, $expectedStatus): void {
+        $this->recoveryMock->expects($this->any())
+            ->method('setRecoveryForUser')
+            ->with($enableRecovery)
+            ->willReturnMap([
+                ['1', true],
+                ['0', false]
+            ]);
+
+
+        $response = $this->controller->userSetRecovery($enableRecovery);
+
+        $this->assertEquals($expectedMessage, $response->getData()['data']['message']);
+        $this->assertEquals($expectedStatus, $response->getStatus());
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->requestMock = $this->getMockBuilder(IRequest::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->configMock = $this->getMockBuilder(IConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->l10nMock = $this->getMockBuilder(IL10N::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        // Make l10n work in our tests
+        $this->l10nMock->expects($this->any())
+            ->method('t')
+            ->willReturnArgument(0);
+
+        $this->recoveryMock = $this->getMockBuilder(Recovery::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->controller = new RecoveryController('encryption',
+            $this->requestMock,
+            $this->configMock,
+            $this->l10nMock,
+            $this->recoveryMock);
+    }
 }

apps/encryption/tests/KeyManagerTest.php

Indentation +668 added lines, -668 removed lines

@@ -31,672 +31,672 @@
 
 class KeyManagerTest extends TestCase {
 
-	protected KeyManager $instance;
-
-	protected string $userId;
-	protected string $systemKeyId;
-	protected IStorage&MockObject $keyStorageMock;
-	protected Crypt&MockObject $cryptMock;
-	protected IUserSession&MockObject $userMock;
-	protected Session&MockObject $sessionMock;
-	protected LoggerInterface&MockObject $logMock;
-	protected Util&MockObject $utilMock;
-	protected IConfig&MockObject $configMock;
-	protected ILockingProvider&MockObject $lockingProviderMock;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->userId = 'user1';
-		$this->systemKeyId = 'systemKeyId';
-		$this->keyStorageMock = $this->createMock(IStorage::class);
-		$this->cryptMock = $this->getMockBuilder(Crypt::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->configMock = $this->createMock(IConfig::class);
-		$this->configMock->expects($this->any())
-			->method('getAppValue')
-			->willReturn($this->systemKeyId);
-		$this->userMock = $this->createMock(IUserSession::class);
-		$this->sessionMock = $this->getMockBuilder(Session::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->logMock = $this->createMock(LoggerInterface::class);
-		$this->utilMock = $this->getMockBuilder(Util::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->lockingProviderMock = $this->createMock(ILockingProvider::class);
-
-		$this->instance = new KeyManager(
-			$this->keyStorageMock,
-			$this->cryptMock,
-			$this->configMock,
-			$this->userMock,
-			$this->sessionMock,
-			$this->logMock,
-			$this->utilMock,
-			$this->lockingProviderMock
-		);
-	}
-
-	public function testDeleteShareKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('deleteFileKey')
-			->with($this->equalTo('/path'), $this->equalTo('keyId.shareKey'))
-			->willReturn(true);
-
-		$this->assertTrue(
-			$this->instance->deleteShareKey('/path', 'keyId')
-		);
-	}
-
-	public function testGetPrivateKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('getUserKey')
-			->with($this->equalTo($this->userId), $this->equalTo('privateKey'))
-			->willReturn('privateKey');
-
-
-		$this->assertSame('privateKey',
-			$this->instance->getPrivateKey($this->userId)
-		);
-	}
-
-	public function testGetPublicKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('getUserKey')
-			->with($this->equalTo($this->userId), $this->equalTo('publicKey'))
-			->willReturn('publicKey');
-
-
-		$this->assertSame('publicKey',
-			$this->instance->getPublicKey($this->userId)
-		);
-	}
-
-	public function testRecoveryKeyExists(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('getSystemUserKey')
-			->with($this->equalTo($this->systemKeyId . '.publicKey'))
-			->willReturn('recoveryKey');
-
-
-		$this->assertTrue($this->instance->recoveryKeyExists());
-	}
-
-	public function testCheckRecoveryKeyPassword(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('getSystemUserKey')
-			->with($this->equalTo($this->systemKeyId . '.privateKey'))
-			->willReturn('recoveryKey');
-		$this->cryptMock->expects($this->any())
-			->method('decryptPrivateKey')
-			->with($this->equalTo('recoveryKey'), $this->equalTo('pass'))
-			->willReturn('decryptedRecoveryKey');
-
-		$this->assertTrue($this->instance->checkRecoveryPassword('pass'));
-	}
-
-	public function testSetPublicKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('setUserKey')
-			->with(
-				$this->equalTo($this->userId),
-				$this->equalTo('publicKey'),
-				$this->equalTo('key'))
-			->willReturn(true);
-
-
-		$this->assertTrue(
-			$this->instance->setPublicKey($this->userId, 'key')
-		);
-	}
-
-	public function testSetPrivateKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('setUserKey')
-			->with(
-				$this->equalTo($this->userId),
-				$this->equalTo('privateKey'),
-				$this->equalTo('key'))
-			->willReturn(true);
-
-
-		$this->assertTrue(
-			$this->instance->setPrivateKey($this->userId, 'key')
-		);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestUserHasKeys')]
-	public function testUserHasKeys($key, $expected): void {
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('getUserKey')
-			->with($this->equalTo($this->userId), $this->anything())
-			->willReturn($key);
-
-
-		$this->assertSame($expected,
-			$this->instance->userHasKeys($this->userId)
-		);
-	}
-
-	public static function dataTestUserHasKeys(): array {
-		return [
-			['key', true],
-			['', false]
-		];
-	}
-
-
-	public function testUserHasKeysMissingPrivateKey(): void {
-		$this->expectException(PrivateKeyMissingException::class);
-
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('getUserKey')
-			->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
-				if ($keyID === 'privateKey') {
-					return '';
-				}
-				return 'key';
-			});
-
-		$this->instance->userHasKeys($this->userId);
-	}
-
-
-	public function testUserHasKeysMissingPublicKey(): void {
-		$this->expectException(PublicKeyMissingException::class);
-
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('getUserKey')
-			->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
-				if ($keyID === 'publicKey') {
-					return '';
-				}
-				return 'key';
-			});
-
-		$this->instance->userHasKeys($this->userId);
-	}
-
-	/**
-	 * @param bool $useMasterKey
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestInit')]
-	public function testInit($useMasterKey): void {
-		/** @var KeyManager&MockObject $instance */
-		$instance = $this->getMockBuilder(KeyManager::class)
-			->setConstructorArgs(
-				[
-					$this->keyStorageMock,
-					$this->cryptMock,
-					$this->configMock,
-					$this->userMock,
-					$this->sessionMock,
-					$this->logMock,
-					$this->utilMock,
-					$this->lockingProviderMock
-				]
-			)->onlyMethods(['getMasterKeyId', 'getMasterKeyPassword', 'getSystemPrivateKey', 'getPrivateKey'])
-			->getMock();
-
-		$this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn($useMasterKey);
-
-		$sessionSetStatusCalls = [];
-		$this->sessionMock->expects($this->exactly(2))
-			->method('setStatus')
-			->willReturnCallback(function (string $status) use (&$sessionSetStatusCalls): void {
-				$sessionSetStatusCalls[] = $status;
-			});
-
-		$instance->expects($this->any())->method('getMasterKeyId')->willReturn('masterKeyId');
-		$instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
-		$instance->expects($this->any())->method('getSystemPrivateKey')->with('masterKeyId')->willReturn('privateMasterKey');
-		$instance->expects($this->any())->method('getPrivateKey')->with($this->userId)->willReturn('privateUserKey');
-
-		if ($useMasterKey) {
-			$this->cryptMock->expects($this->once())->method('decryptPrivateKey')
-				->with('privateMasterKey', 'masterKeyPassword', 'masterKeyId')
-				->willReturn('key');
-		} else {
-			$this->cryptMock->expects($this->once())->method('decryptPrivateKey')
-				->with('privateUserKey', 'pass', $this->userId)
-				->willReturn('key');
-		}
-
-		$this->sessionMock->expects($this->once())->method('setPrivateKey')
-			->with('key');
-
-		$this->assertTrue($instance->init($this->userId, 'pass'));
-		self::assertEquals([
-			Session::INIT_EXECUTED,
-			Session::INIT_SUCCESSFUL,
-		], $sessionSetStatusCalls);
-	}
-
-	public static function dataTestInit(): array {
-		return [
-			[true],
-			[false]
-		];
-	}
-
-
-	public function testSetRecoveryKey(): void {
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('setSystemUserKey')
-			->willReturn(true);
-		$this->cryptMock->expects($this->any())
-			->method('encryptPrivateKey')
-			->with($this->equalTo('privateKey'), $this->equalTo('pass'))
-			->willReturn('decryptedPrivateKey');
-
-
-		$this->assertTrue(
-			$this->instance->setRecoveryKey('pass',
-				['publicKey' => 'publicKey', 'privateKey' => 'privateKey'])
-		);
-	}
-
-	public function testSetSystemPrivateKey(): void {
-		$this->keyStorageMock->expects($this->exactly(1))
-			->method('setSystemUserKey')
-			->with($this->equalTo('keyId.privateKey'), $this->equalTo('key'))
-			->willReturn(true);
-
-
-		$this->assertTrue(
-			$this->instance->setSystemPrivateKey('keyId', 'key')
-		);
-	}
-
-	public function testGetSystemPrivateKey(): void {
-		$this->keyStorageMock->expects($this->exactly(1))
-			->method('getSystemUserKey')
-			->with($this->equalTo('keyId.privateKey'))
-			->willReturn('systemPrivateKey');
-
-
-		$this->assertSame('systemPrivateKey',
-			$this->instance->getSystemPrivateKey('keyId')
-		);
-	}
-
-	public function testGetEncryptedFileKey(): void {
-		$this->keyStorageMock->expects($this->once())
-			->method('getFileKey')
-			->with('/', 'fileKey')
-			->willReturn(true);
-
-		$this->assertTrue($this->instance->getEncryptedFileKey('/'));
-	}
-
-	public static function dataTestGetFileKey(): array {
-		return [
-			['user1', false, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
-			['user1', false, 'privateKey', '', 'multiKeyDecryptResult'],
-			['user1', false, '', 'legacyKey', ''],
-			['user1', false, '', '', ''],
-			['user1', true, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
-			['user1', true, 'privateKey', '', 'multiKeyDecryptResult'],
-			['user1', true, '', 'legacyKey', ''],
-			['user1', true, '', '', ''],
-			[null, false, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
-			[null, false, 'privateKey', '', 'multiKeyDecryptResult'],
-			[null, false, '', 'legacyKey', ''],
-			[null, false, '', '', ''],
-			[null, true, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
-			[null, true, 'privateKey', '', 'multiKeyDecryptResult'],
-			[null, true, '', 'legacyKey', ''],
-			[null, true, '', '', ''],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetFileKey')]
-	public function testGetFileKey(?string $uid, bool $isMasterKeyEnabled, string $privateKey, string $encryptedFileKey, string $expected): void {
-		$path = '/foo.txt';
-
-		if ($isMasterKeyEnabled) {
-			$expectedUid = 'masterKeyId';
-			$this->configMock->expects($this->any())->method('getSystemValue')->with('secret')
-				->willReturn('password');
-		} elseif (!$uid) {
-			$expectedUid = 'systemKeyId';
-		} else {
-			$expectedUid = $uid;
-		}
-
-		$this->invokePrivate($this->instance, 'masterKeyId', ['masterKeyId']);
-		$this->invokePrivate($this->instance, 'keyUid', [$uid]);
-
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('getFileKey')
-			->willReturnMap([
-				[$path, 'fileKey', 'OC_DEFAULT_MODULE', $encryptedFileKey],
-				[$path, $expectedUid . '.shareKey', 'OC_DEFAULT_MODULE', 'fileKey'],
-			]);
-
-		$this->utilMock->expects($this->any())->method('isMasterKeyEnabled')
-			->willReturn($isMasterKeyEnabled);
-
-		if (is_null($uid)) {
-			$this->keyStorageMock->expects($this->once())
-				->method('getSystemUserKey')
-				->willReturn(true);
-			$this->cryptMock->expects($this->once())
-				->method('decryptPrivateKey')
-				->willReturn($privateKey);
-		} else {
-			$this->keyStorageMock->expects($this->never())
-				->method('getSystemUserKey');
-			$this->sessionMock->expects($this->once())->method('getPrivateKey')->willReturn($privateKey);
-		}
-
-		if (!empty($encryptedFileKey)) {
-			$this->cryptMock->expects($this->never())
-				->method('multiKeyDecrypt');
-			if ($privateKey) {
-				$this->cryptMock->expects($this->once())
-					->method('multiKeyDecryptLegacy')
-					->willReturn('multiKeyDecryptResult');
-			} else {
-				$this->cryptMock->expects($this->never())
-					->method('multiKeyDecryptLegacy');
-			}
-		} else {
-			$this->cryptMock->expects($this->never())
-				->method('multiKeyDecryptLegacy');
-			if ($privateKey) {
-				$this->cryptMock->expects($this->once())
-					->method('multiKeyDecrypt')
-					->willReturn('multiKeyDecryptResult');
-			} else {
-				$this->cryptMock->expects($this->never())
-					->method('multiKeyDecrypt');
-			}
-		}
-
-		$this->assertSame($expected,
-			$this->instance->getFileKey($path, null)
-		);
-	}
-
-	public function testDeletePrivateKey(): void {
-		$this->keyStorageMock->expects($this->once())
-			->method('deleteUserKey')
-			->with('user1', 'privateKey')
-			->willReturn(true);
-
-		$this->assertTrue(self::invokePrivate($this->instance,
-			'deletePrivateKey',
-			[$this->userId]));
-	}
-
-	public function testDeleteAllFileKeys(): void {
-		$this->keyStorageMock->expects($this->once())
-			->method('deleteAllFileKeys')
-			->willReturn(true);
-
-		$this->assertTrue($this->instance->deleteAllFileKeys('/'));
-	}
-
-	/**
-	 * test add public share key and or recovery key to the list of public keys
-	 *
-	 *
-	 * @param array $accessList
-	 * @param array $publicKeys
-	 * @param string $uid
-	 * @param array $expectedKeys
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestAddSystemKeys')]
-	public function testAddSystemKeys($accessList, $publicKeys, $uid, $expectedKeys): void {
-		$publicShareKeyId = 'publicShareKey';
-		$recoveryKeyId = 'recoveryKey';
-
-		$this->keyStorageMock->expects($this->any())
-			->method('getSystemUserKey')
-			->willReturnCallback(function ($keyId, $encryptionModuleId) {
-				return $keyId;
-			});
-
-		$this->utilMock->expects($this->any())
-			->method('isRecoveryEnabledForUser')
-			->willReturnCallback(function ($uid) {
-				if ($uid === 'user1') {
-					return true;
-				}
-				return false;
-			});
-
-		// set key IDs
-		self::invokePrivate($this->instance, 'publicShareKeyId', [$publicShareKeyId]);
-		self::invokePrivate($this->instance, 'recoveryKeyId', [$recoveryKeyId]);
-
-		$result = $this->instance->addSystemKeys($accessList, $publicKeys, $uid);
-
-		foreach ($expectedKeys as $expected) {
-			$this->assertArrayHasKey($expected, $result);
-		}
-
-		$this->assertSameSize($expectedKeys, $result);
-	}
-
-	/**
-	 * data provider for testAddSystemKeys()
-	 *
-	 * @return array
-	 */
-	public static function dataTestAddSystemKeys(): array {
-		return [
-			[['public' => true],[], 'user1', ['publicShareKey', 'recoveryKey']],
-			[['public' => false], [], 'user1', ['recoveryKey']],
-			[['public' => true],[], 'user2', ['publicShareKey']],
-			[['public' => false], [], 'user2', []],
-		];
-	}
-
-	public function testGetMasterKeyId(): void {
-		$this->assertSame('systemKeyId', $this->instance->getMasterKeyId());
-	}
-
-	public function testGetPublicMasterKey(): void {
-		$this->keyStorageMock->expects($this->once())->method('getSystemUserKey')
-			->with('systemKeyId.publicKey', Encryption::ID)
-			->willReturn(true);
-
-		$this->assertTrue(
-			$this->instance->getPublicMasterKey()
-		);
-	}
-
-	public function testGetMasterKeyPassword(): void {
-		$this->configMock->expects($this->once())->method('getSystemValue')->with('secret')
-			->willReturn('password');
-
-		$this->assertSame('password',
-			$this->invokePrivate($this->instance, 'getMasterKeyPassword', [])
-		);
-	}
-
-
-	public function testGetMasterKeyPasswordException(): void {
-		$this->expectException(\Exception::class);
-
-		$this->configMock->expects($this->once())->method('getSystemValue')->with('secret')
-			->willReturn('');
-
-		$this->invokePrivate($this->instance, 'getMasterKeyPassword', []);
-	}
-
-	/**
-	 * @param $masterKey
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestValidateMasterKey')]
-	public function testValidateMasterKey($masterKey): void {
-		/** @var KeyManager&MockObject $instance */
-		$instance = $this->getMockBuilder(KeyManager::class)
-			->setConstructorArgs(
-				[
-					$this->keyStorageMock,
-					$this->cryptMock,
-					$this->configMock,
-					$this->userMock,
-					$this->sessionMock,
-					$this->logMock,
-					$this->utilMock,
-					$this->lockingProviderMock
-				]
-			)->onlyMethods(['getPublicMasterKey', 'setSystemPrivateKey', 'getMasterKeyPassword'])
-			->getMock();
-
-		$this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
-
-		$instance->expects($this->once())->method('getPublicMasterKey')
-			->willReturn($masterKey);
-
-		$instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
-		$this->cryptMock->expects($this->any())->method('generateHeader')->willReturn('header');
-
-		if (empty($masterKey)) {
-			$this->cryptMock->expects($this->once())->method('createKeyPair')
-				->willReturn(['publicKey' => 'public', 'privateKey' => 'private']);
-			$this->keyStorageMock->expects($this->once())->method('setSystemUserKey')
-				->with('systemKeyId.publicKey', 'public', Encryption::ID);
-			$this->cryptMock->expects($this->once())->method('encryptPrivateKey')
-				->with('private', 'masterKeyPassword', 'systemKeyId')
-				->willReturn('EncryptedKey');
-			$this->lockingProviderMock->expects($this->once())
-				->method('acquireLock');
-			$instance->expects($this->once())->method('setSystemPrivateKey')
-				->with('systemKeyId', 'headerEncryptedKey');
-		} else {
-			$this->cryptMock->expects($this->never())->method('createKeyPair');
-			$this->keyStorageMock->expects($this->never())->method('setSystemUserKey');
-			$this->cryptMock->expects($this->never())->method('encryptPrivateKey');
-			$instance->expects($this->never())->method('setSystemPrivateKey');
-		}
-
-		$instance->validateMasterKey();
-	}
-
-	public function testValidateMasterKeyLocked(): void {
-		/** @var KeyManager&MockObject $instance */
-		$instance = $this->getMockBuilder(KeyManager::class)
-			->setConstructorArgs([
-				$this->keyStorageMock,
-				$this->cryptMock,
-				$this->configMock,
-				$this->userMock,
-				$this->sessionMock,
-				$this->logMock,
-				$this->utilMock,
-				$this->lockingProviderMock
-			])
-			->onlyMethods(['getPublicMasterKey', 'getPrivateMasterKey', 'setSystemPrivateKey', 'getMasterKeyPassword'])
-			->getMock();
-
-		$this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
-
-		$instance->expects($this->once())->method('getPublicMasterKey')
-			->willReturn('');
-		$instance->expects($this->once())->method('getPrivateMasterKey')
-			->willReturn('');
-
-		$instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
-		$this->cryptMock->expects($this->any())->method('generateHeader')->willReturn('header');
-
-		$this->lockingProviderMock->expects($this->once())
-			->method('acquireLock')
-			->willThrowException(new LockedException('encryption-generateMasterKey'));
-
-		$this->expectException(LockedException::class);
-		$instance->validateMasterKey();
-	}
-
-	public static function dataTestValidateMasterKey(): array {
-		return [
-			['masterKey'],
-			['']
-		];
-	}
-
-	public function testGetVersionWithoutFileInfo(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()->getMock();
-		$view->expects($this->once())
-			->method('getFileInfo')
-			->with('/admin/files/myfile.txt')
-			->willReturn(false);
-
-		/** @var View $view */
-		$this->assertSame(0, $this->instance->getVersion('/admin/files/myfile.txt', $view));
-	}
-
-	public function testGetVersionWithFileInfo(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()->getMock();
-		$fileInfo = $this->getMockBuilder(FileInfo::class)
-			->disableOriginalConstructor()->getMock();
-		$fileInfo->expects($this->once())
-			->method('getEncryptedVersion')
-			->willReturn(1337);
-		$view->expects($this->once())
-			->method('getFileInfo')
-			->with('/admin/files/myfile.txt')
-			->willReturn($fileInfo);
-
-		/** @var View $view */
-		$this->assertSame(1337, $this->instance->getVersion('/admin/files/myfile.txt', $view));
-	}
-
-	public function testSetVersionWithFileInfo(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()->getMock();
-		$cache = $this->getMockBuilder(ICache::class)
-			->disableOriginalConstructor()->getMock();
-		$cache->expects($this->once())
-			->method('update')
-			->with(123, ['encrypted' => 5, 'encryptedVersion' => 5]);
-		$storage = $this->getMockBuilder(FilesIStorage::class)
-			->disableOriginalConstructor()->getMock();
-		$storage->expects($this->once())
-			->method('getCache')
-			->willReturn($cache);
-		$fileInfo = $this->getMockBuilder(FileInfo::class)
-			->disableOriginalConstructor()->getMock();
-		$fileInfo->expects($this->once())
-			->method('getStorage')
-			->willReturn($storage);
-		$fileInfo->expects($this->once())
-			->method('getId')
-			->willReturn(123);
-		$view->expects($this->once())
-			->method('getFileInfo')
-			->with('/admin/files/myfile.txt')
-			->willReturn($fileInfo);
-
-		/** @var View $view */
-		$this->instance->setVersion('/admin/files/myfile.txt', 5, $view);
-	}
-
-	public function testSetVersionWithoutFileInfo(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()->getMock();
-		$view->expects($this->once())
-			->method('getFileInfo')
-			->with('/admin/files/myfile.txt')
-			->willReturn(false);
-
-		/** @var View $view */
-		$this->instance->setVersion('/admin/files/myfile.txt', 5, $view);
-	}
-
-	public function testBackupUserKeys(): void {
-		$this->keyStorageMock->expects($this->once())->method('backupUserKeys')
-			->with('OC_DEFAULT_MODULE', 'test', 'user1');
-		$this->instance->backupUserKeys('test', 'user1');
-	}
+    protected KeyManager $instance;
+
+    protected string $userId;
+    protected string $systemKeyId;
+    protected IStorage&MockObject $keyStorageMock;
+    protected Crypt&MockObject $cryptMock;
+    protected IUserSession&MockObject $userMock;
+    protected Session&MockObject $sessionMock;
+    protected LoggerInterface&MockObject $logMock;
+    protected Util&MockObject $utilMock;
+    protected IConfig&MockObject $configMock;
+    protected ILockingProvider&MockObject $lockingProviderMock;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->userId = 'user1';
+        $this->systemKeyId = 'systemKeyId';
+        $this->keyStorageMock = $this->createMock(IStorage::class);
+        $this->cryptMock = $this->getMockBuilder(Crypt::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->configMock = $this->createMock(IConfig::class);
+        $this->configMock->expects($this->any())
+            ->method('getAppValue')
+            ->willReturn($this->systemKeyId);
+        $this->userMock = $this->createMock(IUserSession::class);
+        $this->sessionMock = $this->getMockBuilder(Session::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->logMock = $this->createMock(LoggerInterface::class);
+        $this->utilMock = $this->getMockBuilder(Util::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->lockingProviderMock = $this->createMock(ILockingProvider::class);
+
+        $this->instance = new KeyManager(
+            $this->keyStorageMock,
+            $this->cryptMock,
+            $this->configMock,
+            $this->userMock,
+            $this->sessionMock,
+            $this->logMock,
+            $this->utilMock,
+            $this->lockingProviderMock
+        );
+    }
+
+    public function testDeleteShareKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('deleteFileKey')
+            ->with($this->equalTo('/path'), $this->equalTo('keyId.shareKey'))
+            ->willReturn(true);
+
+        $this->assertTrue(
+            $this->instance->deleteShareKey('/path', 'keyId')
+        );
+    }
+
+    public function testGetPrivateKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('getUserKey')
+            ->with($this->equalTo($this->userId), $this->equalTo('privateKey'))
+            ->willReturn('privateKey');
+
+
+        $this->assertSame('privateKey',
+            $this->instance->getPrivateKey($this->userId)
+        );
+    }
+
+    public function testGetPublicKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('getUserKey')
+            ->with($this->equalTo($this->userId), $this->equalTo('publicKey'))
+            ->willReturn('publicKey');
+
+
+        $this->assertSame('publicKey',
+            $this->instance->getPublicKey($this->userId)
+        );
+    }
+
+    public function testRecoveryKeyExists(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('getSystemUserKey')
+            ->with($this->equalTo($this->systemKeyId . '.publicKey'))
+            ->willReturn('recoveryKey');
+
+
+        $this->assertTrue($this->instance->recoveryKeyExists());
+    }
+
+    public function testCheckRecoveryKeyPassword(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('getSystemUserKey')
+            ->with($this->equalTo($this->systemKeyId . '.privateKey'))
+            ->willReturn('recoveryKey');
+        $this->cryptMock->expects($this->any())
+            ->method('decryptPrivateKey')
+            ->with($this->equalTo('recoveryKey'), $this->equalTo('pass'))
+            ->willReturn('decryptedRecoveryKey');
+
+        $this->assertTrue($this->instance->checkRecoveryPassword('pass'));
+    }
+
+    public function testSetPublicKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('setUserKey')
+            ->with(
+                $this->equalTo($this->userId),
+                $this->equalTo('publicKey'),
+                $this->equalTo('key'))
+            ->willReturn(true);
+
+
+        $this->assertTrue(
+            $this->instance->setPublicKey($this->userId, 'key')
+        );
+    }
+
+    public function testSetPrivateKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('setUserKey')
+            ->with(
+                $this->equalTo($this->userId),
+                $this->equalTo('privateKey'),
+                $this->equalTo('key'))
+            ->willReturn(true);
+
+
+        $this->assertTrue(
+            $this->instance->setPrivateKey($this->userId, 'key')
+        );
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestUserHasKeys')]
+    public function testUserHasKeys($key, $expected): void {
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('getUserKey')
+            ->with($this->equalTo($this->userId), $this->anything())
+            ->willReturn($key);
+
+
+        $this->assertSame($expected,
+            $this->instance->userHasKeys($this->userId)
+        );
+    }
+
+    public static function dataTestUserHasKeys(): array {
+        return [
+            ['key', true],
+            ['', false]
+        ];
+    }
+
+
+    public function testUserHasKeysMissingPrivateKey(): void {
+        $this->expectException(PrivateKeyMissingException::class);
+
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('getUserKey')
+            ->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
+                if ($keyID === 'privateKey') {
+                    return '';
+                }
+                return 'key';
+            });
+
+        $this->instance->userHasKeys($this->userId);
+    }
+
+
+    public function testUserHasKeysMissingPublicKey(): void {
+        $this->expectException(PublicKeyMissingException::class);
+
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('getUserKey')
+            ->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
+                if ($keyID === 'publicKey') {
+                    return '';
+                }
+                return 'key';
+            });
+
+        $this->instance->userHasKeys($this->userId);
+    }
+
+    /**
+     * @param bool $useMasterKey
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestInit')]
+    public function testInit($useMasterKey): void {
+        /** @var KeyManager&MockObject $instance */
+        $instance = $this->getMockBuilder(KeyManager::class)
+            ->setConstructorArgs(
+                [
+                    $this->keyStorageMock,
+                    $this->cryptMock,
+                    $this->configMock,
+                    $this->userMock,
+                    $this->sessionMock,
+                    $this->logMock,
+                    $this->utilMock,
+                    $this->lockingProviderMock
+                ]
+            )->onlyMethods(['getMasterKeyId', 'getMasterKeyPassword', 'getSystemPrivateKey', 'getPrivateKey'])
+            ->getMock();
+
+        $this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn($useMasterKey);
+
+        $sessionSetStatusCalls = [];
+        $this->sessionMock->expects($this->exactly(2))
+            ->method('setStatus')
+            ->willReturnCallback(function (string $status) use (&$sessionSetStatusCalls): void {
+                $sessionSetStatusCalls[] = $status;
+            });
+
+        $instance->expects($this->any())->method('getMasterKeyId')->willReturn('masterKeyId');
+        $instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
+        $instance->expects($this->any())->method('getSystemPrivateKey')->with('masterKeyId')->willReturn('privateMasterKey');
+        $instance->expects($this->any())->method('getPrivateKey')->with($this->userId)->willReturn('privateUserKey');
+
+        if ($useMasterKey) {
+            $this->cryptMock->expects($this->once())->method('decryptPrivateKey')
+                ->with('privateMasterKey', 'masterKeyPassword', 'masterKeyId')
+                ->willReturn('key');
+        } else {
+            $this->cryptMock->expects($this->once())->method('decryptPrivateKey')
+                ->with('privateUserKey', 'pass', $this->userId)
+                ->willReturn('key');
+        }
+
+        $this->sessionMock->expects($this->once())->method('setPrivateKey')
+            ->with('key');
+
+        $this->assertTrue($instance->init($this->userId, 'pass'));
+        self::assertEquals([
+            Session::INIT_EXECUTED,
+            Session::INIT_SUCCESSFUL,
+        ], $sessionSetStatusCalls);
+    }
+
+    public static function dataTestInit(): array {
+        return [
+            [true],
+            [false]
+        ];
+    }
+
+
+    public function testSetRecoveryKey(): void {
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('setSystemUserKey')
+            ->willReturn(true);
+        $this->cryptMock->expects($this->any())
+            ->method('encryptPrivateKey')
+            ->with($this->equalTo('privateKey'), $this->equalTo('pass'))
+            ->willReturn('decryptedPrivateKey');
+
+
+        $this->assertTrue(
+            $this->instance->setRecoveryKey('pass',
+                ['publicKey' => 'publicKey', 'privateKey' => 'privateKey'])
+        );
+    }
+
+    public function testSetSystemPrivateKey(): void {
+        $this->keyStorageMock->expects($this->exactly(1))
+            ->method('setSystemUserKey')
+            ->with($this->equalTo('keyId.privateKey'), $this->equalTo('key'))
+            ->willReturn(true);
+
+
+        $this->assertTrue(
+            $this->instance->setSystemPrivateKey('keyId', 'key')
+        );
+    }
+
+    public function testGetSystemPrivateKey(): void {
+        $this->keyStorageMock->expects($this->exactly(1))
+            ->method('getSystemUserKey')
+            ->with($this->equalTo('keyId.privateKey'))
+            ->willReturn('systemPrivateKey');
+
+
+        $this->assertSame('systemPrivateKey',
+            $this->instance->getSystemPrivateKey('keyId')
+        );
+    }
+
+    public function testGetEncryptedFileKey(): void {
+        $this->keyStorageMock->expects($this->once())
+            ->method('getFileKey')
+            ->with('/', 'fileKey')
+            ->willReturn(true);
+
+        $this->assertTrue($this->instance->getEncryptedFileKey('/'));
+    }
+
+    public static function dataTestGetFileKey(): array {
+        return [
+            ['user1', false, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
+            ['user1', false, 'privateKey', '', 'multiKeyDecryptResult'],
+            ['user1', false, '', 'legacyKey', ''],
+            ['user1', false, '', '', ''],
+            ['user1', true, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
+            ['user1', true, 'privateKey', '', 'multiKeyDecryptResult'],
+            ['user1', true, '', 'legacyKey', ''],
+            ['user1', true, '', '', ''],
+            [null, false, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
+            [null, false, 'privateKey', '', 'multiKeyDecryptResult'],
+            [null, false, '', 'legacyKey', ''],
+            [null, false, '', '', ''],
+            [null, true, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
+            [null, true, 'privateKey', '', 'multiKeyDecryptResult'],
+            [null, true, '', 'legacyKey', ''],
+            [null, true, '', '', ''],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetFileKey')]
+    public function testGetFileKey(?string $uid, bool $isMasterKeyEnabled, string $privateKey, string $encryptedFileKey, string $expected): void {
+        $path = '/foo.txt';
+
+        if ($isMasterKeyEnabled) {
+            $expectedUid = 'masterKeyId';
+            $this->configMock->expects($this->any())->method('getSystemValue')->with('secret')
+                ->willReturn('password');
+        } elseif (!$uid) {
+            $expectedUid = 'systemKeyId';
+        } else {
+            $expectedUid = $uid;
+        }
+
+        $this->invokePrivate($this->instance, 'masterKeyId', ['masterKeyId']);
+        $this->invokePrivate($this->instance, 'keyUid', [$uid]);
+
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('getFileKey')
+            ->willReturnMap([
+                [$path, 'fileKey', 'OC_DEFAULT_MODULE', $encryptedFileKey],
+                [$path, $expectedUid . '.shareKey', 'OC_DEFAULT_MODULE', 'fileKey'],
+            ]);
+
+        $this->utilMock->expects($this->any())->method('isMasterKeyEnabled')
+            ->willReturn($isMasterKeyEnabled);
+
+        if (is_null($uid)) {
+            $this->keyStorageMock->expects($this->once())
+                ->method('getSystemUserKey')
+                ->willReturn(true);
+            $this->cryptMock->expects($this->once())
+                ->method('decryptPrivateKey')
+                ->willReturn($privateKey);
+        } else {
+            $this->keyStorageMock->expects($this->never())
+                ->method('getSystemUserKey');
+            $this->sessionMock->expects($this->once())->method('getPrivateKey')->willReturn($privateKey);
+        }
+
+        if (!empty($encryptedFileKey)) {
+            $this->cryptMock->expects($this->never())
+                ->method('multiKeyDecrypt');
+            if ($privateKey) {
+                $this->cryptMock->expects($this->once())
+                    ->method('multiKeyDecryptLegacy')
+                    ->willReturn('multiKeyDecryptResult');
+            } else {
+                $this->cryptMock->expects($this->never())
+                    ->method('multiKeyDecryptLegacy');
+            }
+        } else {
+            $this->cryptMock->expects($this->never())
+                ->method('multiKeyDecryptLegacy');
+            if ($privateKey) {
+                $this->cryptMock->expects($this->once())
+                    ->method('multiKeyDecrypt')
+                    ->willReturn('multiKeyDecryptResult');
+            } else {
+                $this->cryptMock->expects($this->never())
+                    ->method('multiKeyDecrypt');
+            }
+        }
+
+        $this->assertSame($expected,
+            $this->instance->getFileKey($path, null)
+        );
+    }
+
+    public function testDeletePrivateKey(): void {
+        $this->keyStorageMock->expects($this->once())
+            ->method('deleteUserKey')
+            ->with('user1', 'privateKey')
+            ->willReturn(true);
+
+        $this->assertTrue(self::invokePrivate($this->instance,
+            'deletePrivateKey',
+            [$this->userId]));
+    }
+
+    public function testDeleteAllFileKeys(): void {
+        $this->keyStorageMock->expects($this->once())
+            ->method('deleteAllFileKeys')
+            ->willReturn(true);
+
+        $this->assertTrue($this->instance->deleteAllFileKeys('/'));
+    }
+
+    /**
+     * test add public share key and or recovery key to the list of public keys
+     *
+     *
+     * @param array $accessList
+     * @param array $publicKeys
+     * @param string $uid
+     * @param array $expectedKeys
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestAddSystemKeys')]
+    public function testAddSystemKeys($accessList, $publicKeys, $uid, $expectedKeys): void {
+        $publicShareKeyId = 'publicShareKey';
+        $recoveryKeyId = 'recoveryKey';
+
+        $this->keyStorageMock->expects($this->any())
+            ->method('getSystemUserKey')
+            ->willReturnCallback(function ($keyId, $encryptionModuleId) {
+                return $keyId;
+            });
+
+        $this->utilMock->expects($this->any())
+            ->method('isRecoveryEnabledForUser')
+            ->willReturnCallback(function ($uid) {
+                if ($uid === 'user1') {
+                    return true;
+                }
+                return false;
+            });
+
+        // set key IDs
+        self::invokePrivate($this->instance, 'publicShareKeyId', [$publicShareKeyId]);
+        self::invokePrivate($this->instance, 'recoveryKeyId', [$recoveryKeyId]);
+
+        $result = $this->instance->addSystemKeys($accessList, $publicKeys, $uid);
+
+        foreach ($expectedKeys as $expected) {
+            $this->assertArrayHasKey($expected, $result);
+        }
+
+        $this->assertSameSize($expectedKeys, $result);
+    }
+
+    /**
+     * data provider for testAddSystemKeys()
+     *
+     * @return array
+     */
+    public static function dataTestAddSystemKeys(): array {
+        return [
+            [['public' => true],[], 'user1', ['publicShareKey', 'recoveryKey']],
+            [['public' => false], [], 'user1', ['recoveryKey']],
+            [['public' => true],[], 'user2', ['publicShareKey']],
+            [['public' => false], [], 'user2', []],
+        ];
+    }
+
+    public function testGetMasterKeyId(): void {
+        $this->assertSame('systemKeyId', $this->instance->getMasterKeyId());
+    }
+
+    public function testGetPublicMasterKey(): void {
+        $this->keyStorageMock->expects($this->once())->method('getSystemUserKey')
+            ->with('systemKeyId.publicKey', Encryption::ID)
+            ->willReturn(true);
+
+        $this->assertTrue(
+            $this->instance->getPublicMasterKey()
+        );
+    }
+
+    public function testGetMasterKeyPassword(): void {
+        $this->configMock->expects($this->once())->method('getSystemValue')->with('secret')
+            ->willReturn('password');
+
+        $this->assertSame('password',
+            $this->invokePrivate($this->instance, 'getMasterKeyPassword', [])
+        );
+    }
+
+
+    public function testGetMasterKeyPasswordException(): void {
+        $this->expectException(\Exception::class);
+
+        $this->configMock->expects($this->once())->method('getSystemValue')->with('secret')
+            ->willReturn('');
+
+        $this->invokePrivate($this->instance, 'getMasterKeyPassword', []);
+    }
+
+    /**
+     * @param $masterKey
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestValidateMasterKey')]
+    public function testValidateMasterKey($masterKey): void {
+        /** @var KeyManager&MockObject $instance */
+        $instance = $this->getMockBuilder(KeyManager::class)
+            ->setConstructorArgs(
+                [
+                    $this->keyStorageMock,
+                    $this->cryptMock,
+                    $this->configMock,
+                    $this->userMock,
+                    $this->sessionMock,
+                    $this->logMock,
+                    $this->utilMock,
+                    $this->lockingProviderMock
+                ]
+            )->onlyMethods(['getPublicMasterKey', 'setSystemPrivateKey', 'getMasterKeyPassword'])
+            ->getMock();
+
+        $this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
+
+        $instance->expects($this->once())->method('getPublicMasterKey')
+            ->willReturn($masterKey);
+
+        $instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
+        $this->cryptMock->expects($this->any())->method('generateHeader')->willReturn('header');
+
+        if (empty($masterKey)) {
+            $this->cryptMock->expects($this->once())->method('createKeyPair')
+                ->willReturn(['publicKey' => 'public', 'privateKey' => 'private']);
+            $this->keyStorageMock->expects($this->once())->method('setSystemUserKey')
+                ->with('systemKeyId.publicKey', 'public', Encryption::ID);
+            $this->cryptMock->expects($this->once())->method('encryptPrivateKey')
+                ->with('private', 'masterKeyPassword', 'systemKeyId')
+                ->willReturn('EncryptedKey');
+            $this->lockingProviderMock->expects($this->once())
+                ->method('acquireLock');
+            $instance->expects($this->once())->method('setSystemPrivateKey')
+                ->with('systemKeyId', 'headerEncryptedKey');
+        } else {
+            $this->cryptMock->expects($this->never())->method('createKeyPair');
+            $this->keyStorageMock->expects($this->never())->method('setSystemUserKey');
+            $this->cryptMock->expects($this->never())->method('encryptPrivateKey');
+            $instance->expects($this->never())->method('setSystemPrivateKey');
+        }
+
+        $instance->validateMasterKey();
+    }
+
+    public function testValidateMasterKeyLocked(): void {
+        /** @var KeyManager&MockObject $instance */
+        $instance = $this->getMockBuilder(KeyManager::class)
+            ->setConstructorArgs([
+                $this->keyStorageMock,
+                $this->cryptMock,
+                $this->configMock,
+                $this->userMock,
+                $this->sessionMock,
+                $this->logMock,
+                $this->utilMock,
+                $this->lockingProviderMock
+            ])
+            ->onlyMethods(['getPublicMasterKey', 'getPrivateMasterKey', 'setSystemPrivateKey', 'getMasterKeyPassword'])
+            ->getMock();
+
+        $this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
+
+        $instance->expects($this->once())->method('getPublicMasterKey')
+            ->willReturn('');
+        $instance->expects($this->once())->method('getPrivateMasterKey')
+            ->willReturn('');
+
+        $instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
+        $this->cryptMock->expects($this->any())->method('generateHeader')->willReturn('header');
+
+        $this->lockingProviderMock->expects($this->once())
+            ->method('acquireLock')
+            ->willThrowException(new LockedException('encryption-generateMasterKey'));
+
+        $this->expectException(LockedException::class);
+        $instance->validateMasterKey();
+    }
+
+    public static function dataTestValidateMasterKey(): array {
+        return [
+            ['masterKey'],
+            ['']
+        ];
+    }
+
+    public function testGetVersionWithoutFileInfo(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()->getMock();
+        $view->expects($this->once())
+            ->method('getFileInfo')
+            ->with('/admin/files/myfile.txt')
+            ->willReturn(false);
+
+        /** @var View $view */
+        $this->assertSame(0, $this->instance->getVersion('/admin/files/myfile.txt', $view));
+    }
+
+    public function testGetVersionWithFileInfo(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()->getMock();
+        $fileInfo = $this->getMockBuilder(FileInfo::class)
+            ->disableOriginalConstructor()->getMock();
+        $fileInfo->expects($this->once())
+            ->method('getEncryptedVersion')
+            ->willReturn(1337);
+        $view->expects($this->once())
+            ->method('getFileInfo')
+            ->with('/admin/files/myfile.txt')
+            ->willReturn($fileInfo);
+
+        /** @var View $view */
+        $this->assertSame(1337, $this->instance->getVersion('/admin/files/myfile.txt', $view));
+    }
+
+    public function testSetVersionWithFileInfo(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()->getMock();
+        $cache = $this->getMockBuilder(ICache::class)
+            ->disableOriginalConstructor()->getMock();
+        $cache->expects($this->once())
+            ->method('update')
+            ->with(123, ['encrypted' => 5, 'encryptedVersion' => 5]);
+        $storage = $this->getMockBuilder(FilesIStorage::class)
+            ->disableOriginalConstructor()->getMock();
+        $storage->expects($this->once())
+            ->method('getCache')
+            ->willReturn($cache);
+        $fileInfo = $this->getMockBuilder(FileInfo::class)
+            ->disableOriginalConstructor()->getMock();
+        $fileInfo->expects($this->once())
+            ->method('getStorage')
+            ->willReturn($storage);
+        $fileInfo->expects($this->once())
+            ->method('getId')
+            ->willReturn(123);
+        $view->expects($this->once())
+            ->method('getFileInfo')
+            ->with('/admin/files/myfile.txt')
+            ->willReturn($fileInfo);
+
+        /** @var View $view */
+        $this->instance->setVersion('/admin/files/myfile.txt', 5, $view);
+    }
+
+    public function testSetVersionWithoutFileInfo(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()->getMock();
+        $view->expects($this->once())
+            ->method('getFileInfo')
+            ->with('/admin/files/myfile.txt')
+            ->willReturn(false);
+
+        /** @var View $view */
+        $this->instance->setVersion('/admin/files/myfile.txt', 5, $view);
+    }
+
+    public function testBackupUserKeys(): void {
+        $this->keyStorageMock->expects($this->once())->method('backupUserKeys')
+            ->with('OC_DEFAULT_MODULE', 'test', 'user1');
+        $this->instance->backupUserKeys('test', 'user1');
+    }
 }

tests/lib/Traits/EncryptionTrait.php

Indentation +96 added lines, -96 removed lines

@@ -27,100 +27,100 @@
  * Enables encryption
  */
 trait EncryptionTrait {
-	// from MountProviderTrait
-	abstract protected function registerStorageWrapper($name, $wrapper);
-
-	// from phpunit
-	abstract protected static function markTestSkipped(string $message = ''): void;
-	abstract protected static function assertTrue($condition, string $message = ''): void;
-
-	private $encryptionWasEnabled;
-
-	private $originalEncryptionModule;
-
-	/** @var IUserManager */
-	private $userManager;
-	/** @var SetupManager */
-	private $setupManager;
-
-	/**
-	 * @var IConfig
-	 */
-	private $config;
-
-	/**
-	 * @var Application
-	 */
-	private $encryptionApp;
-
-	protected function loginWithEncryption($user = '') {
-		\OC_Util::tearDownFS();
-		\OC_User::setUserId('');
-		// needed for fully logout
-		Server::get(IUserSession::class)->setUser(null);
-
-		$this->setupManager->tearDown();
-
-		\OC_User::setUserId($user);
-		$this->postLogin();
-		\OC_Util::setupFS($user);
-		if ($this->userManager->userExists($user)) {
-			\OC::$server->getUserFolder($user);
-		}
-	}
-
-	protected function setupForUser($name, $password) {
-		$this->setupManager->tearDown();
-		$this->setupManager->setupForUser($this->userManager->get($name));
-
-		$container = $this->encryptionApp->getContainer();
-		/** @var KeyManager $keyManager */
-		$keyManager = $container->query(KeyManager::class);
-		/** @var Setup $userSetup */
-		$userSetup = $container->query(Setup::class);
-		$userSetup->setupUser($name, $password);
-		$encryptionManager = $container->query(IManager::class);
-		$this->encryptionApp->setUp($encryptionManager);
-		$keyManager->init($name, $password);
-		$this->invokePrivate($keyManager, 'keyUid', [$name]);
-	}
-
-	protected function postLogin() {
-		$encryptionWrapper = new EncryptionWrapper(
-			new ArrayCache(),
-			Server::get(\OCP\Encryption\IManager::class),
-			Server::get(LoggerInterface::class)
-		);
-
-		$this->registerStorageWrapper('oc_encryption', [$encryptionWrapper, 'wrapStorage']);
-	}
-
-	protected function setUpEncryptionTrait() {
-		$isReady = Server::get(\OCP\Encryption\IManager::class)->isReady();
-		if (!$isReady) {
-			$this->markTestSkipped('Encryption not ready');
-		}
-
-		$this->userManager = Server::get(IUserManager::class);
-		$this->setupManager = Server::get(SetupManager::class);
-
-		Server::get(IAppManager::class)->loadApp('encryption');
-
-		$this->encryptionApp = new Application([], $isReady);
-
-		$this->config = Server::get(IConfig::class);
-		$this->encryptionWasEnabled = $this->config->getAppValue('core', 'encryption_enabled', 'no');
-		$this->originalEncryptionModule = $this->config->getAppValue('core', 'default_encryption_module');
-		$this->config->setAppValue('core', 'default_encryption_module', Encryption::ID);
-		$this->config->setAppValue('core', 'encryption_enabled', 'yes');
-		$this->assertTrue(Server::get(\OCP\Encryption\IManager::class)->isEnabled());
-	}
-
-	protected function tearDownEncryptionTrait() {
-		if ($this->config) {
-			$this->config->setAppValue('core', 'encryption_enabled', $this->encryptionWasEnabled);
-			$this->config->setAppValue('core', 'default_encryption_module', $this->originalEncryptionModule);
-			$this->config->deleteAppValue('encryption', 'useMasterKey');
-		}
-	}
+    // from MountProviderTrait
+    abstract protected function registerStorageWrapper($name, $wrapper);
+
+    // from phpunit
+    abstract protected static function markTestSkipped(string $message = ''): void;
+    abstract protected static function assertTrue($condition, string $message = ''): void;
+
+    private $encryptionWasEnabled;
+
+    private $originalEncryptionModule;
+
+    /** @var IUserManager */
+    private $userManager;
+    /** @var SetupManager */
+    private $setupManager;
+
+    /**
+     * @var IConfig
+     */
+    private $config;
+
+    /**
+     * @var Application
+     */
+    private $encryptionApp;
+
+    protected function loginWithEncryption($user = '') {
+        \OC_Util::tearDownFS();
+        \OC_User::setUserId('');
+        // needed for fully logout
+        Server::get(IUserSession::class)->setUser(null);
+
+        $this->setupManager->tearDown();
+
+        \OC_User::setUserId($user);
+        $this->postLogin();
+        \OC_Util::setupFS($user);
+        if ($this->userManager->userExists($user)) {
+            \OC::$server->getUserFolder($user);
+        }
+    }
+
+    protected function setupForUser($name, $password) {
+        $this->setupManager->tearDown();
+        $this->setupManager->setupForUser($this->userManager->get($name));
+
+        $container = $this->encryptionApp->getContainer();
+        /** @var KeyManager $keyManager */
+        $keyManager = $container->query(KeyManager::class);
+        /** @var Setup $userSetup */
+        $userSetup = $container->query(Setup::class);
+        $userSetup->setupUser($name, $password);
+        $encryptionManager = $container->query(IManager::class);
+        $this->encryptionApp->setUp($encryptionManager);
+        $keyManager->init($name, $password);
+        $this->invokePrivate($keyManager, 'keyUid', [$name]);
+    }
+
+    protected function postLogin() {
+        $encryptionWrapper = new EncryptionWrapper(
+            new ArrayCache(),
+            Server::get(\OCP\Encryption\IManager::class),
+            Server::get(LoggerInterface::class)
+        );
+
+        $this->registerStorageWrapper('oc_encryption', [$encryptionWrapper, 'wrapStorage']);
+    }
+
+    protected function setUpEncryptionTrait() {
+        $isReady = Server::get(\OCP\Encryption\IManager::class)->isReady();
+        if (!$isReady) {
+            $this->markTestSkipped('Encryption not ready');
+        }
+
+        $this->userManager = Server::get(IUserManager::class);
+        $this->setupManager = Server::get(SetupManager::class);
+
+        Server::get(IAppManager::class)->loadApp('encryption');
+
+        $this->encryptionApp = new Application([], $isReady);
+
+        $this->config = Server::get(IConfig::class);
+        $this->encryptionWasEnabled = $this->config->getAppValue('core', 'encryption_enabled', 'no');
+        $this->originalEncryptionModule = $this->config->getAppValue('core', 'default_encryption_module');
+        $this->config->setAppValue('core', 'default_encryption_module', Encryption::ID);
+        $this->config->setAppValue('core', 'encryption_enabled', 'yes');
+        $this->assertTrue(Server::get(\OCP\Encryption\IManager::class)->isEnabled());
+    }
+
+    protected function tearDownEncryptionTrait() {
+        if ($this->config) {
+            $this->config->setAppValue('core', 'encryption_enabled', $this->encryptionWasEnabled);
+            $this->config->setAppValue('core', 'default_encryption_module', $this->originalEncryptionModule);
+            $this->config->deleteAppValue('encryption', 'useMasterKey');
+        }
+    }
 }