nextcloud / server

lib/private/Security/IdentityProof/Manager.php

Indentation +180 added lines, -180 removed lines

@@ -19,184 +19,184 @@
 use Psr\Log\LoggerInterface;
 
 class Manager {
-	private IAppData $appData;
-
-	protected ICache $cache;
-
-	public function __construct(
-		Factory $appDataFactory,
-		private ICrypto $crypto,
-		private IConfig $config,
-		private LoggerInterface $logger,
-		private ICacheFactory $cacheFactory,
-	) {
-		$this->appData = $appDataFactory->get('identityproof');
-		$this->cache = $this->cacheFactory->createDistributed('identityproof::');
-	}
-
-	/**
-	 * Calls the openssl functions to generate a public and private key.
-	 * In a separate function for unit testing purposes.
-	 *
-	 * @param array $options config options to generate key {@see openssl_csr_new}
-	 *
-	 * @return array [$publicKey, $privateKey]
-	 * @throws \RuntimeException
-	 */
-	protected function generateKeyPair(array $options = []): array {
-		$config = [
-			'digest_alg' => $options['algorithm'] ?? 'sha512',
-			'private_key_bits' => $options['bits'] ?? 2048,
-			'private_key_type' => $options['type'] ?? OPENSSL_KEYTYPE_RSA,
-		];
-
-		// Generate new key
-		$res = openssl_pkey_new($config);
-		if ($res === false) {
-			$this->logOpensslError();
-			throw new \RuntimeException('OpenSSL reported a problem');
-		}
-
-		if (openssl_pkey_export($res, $privateKey, null, $config) === false) {
-			$this->logOpensslError();
-			throw new \RuntimeException('OpenSSL reported a problem');
-		}
-
-		// Extract the public key from $res to $pubKey
-		$publicKey = openssl_pkey_get_details($res);
-		$publicKey = $publicKey['key'];
-
-		return [$publicKey, $privateKey];
-	}
-
-	/**
-	 * Generate a key for a given ID
-	 * Note: If a key already exists it will be overwritten
-	 *
-	 * @param string $id key id
-	 * @param array $options config options to generate key {@see openssl_csr_new}
-	 *
-	 * @throws \RuntimeException
-	 */
-	protected function generateKey(string $id, array $options = []): Key {
-		[$publicKey, $privateKey] = $this->generateKeyPair($options);
-
-		// Write the private and public key to the disk
-		try {
-			$this->appData->newFolder($id);
-		} catch (\Exception) {
-		}
-		$folder = $this->appData->getFolder($id);
-		$folder->newFile('private')
-			->putContent($this->crypto->encrypt($privateKey));
-		$folder->newFile('public')
-			->putContent($publicKey);
-
-		return new Key($publicKey, $privateKey);
-	}
-
-	/**
-	 * Get key for a specific id
-	 *
-	 * @throws \RuntimeException
-	 */
-	protected function retrieveKey(string $id): Key {
-		try {
-			$cachedPublicKey = $this->cache->get($id . '-public');
-			$cachedPrivateKey = $this->cache->get($id . '-private');
-
-			if ($cachedPublicKey !== null && $cachedPrivateKey !== null) {
-				$decryptedPrivateKey = $this->crypto->decrypt($cachedPrivateKey);
-
-				return new Key($cachedPublicKey, $decryptedPrivateKey);
-			}
-
-			$folder = $this->appData->getFolder($id);
-			$privateKey = $folder->getFile('private')->getContent();
-			$publicKey = $folder->getFile('public')->getContent();
-
-			$this->cache->set($id . '-public', $publicKey);
-			$this->cache->set($id . '-private', $privateKey);
-
-			$decryptedPrivateKey = $this->crypto->decrypt($privateKey);
-			return new Key($publicKey, $decryptedPrivateKey);
-		} catch (\Exception $e) {
-			return $this->generateKey($id);
-		}
-	}
-
-	/**
-	 * Get public and private key for $user
-	 *
-	 * @throws \RuntimeException
-	 */
-	public function getKey(IUser $user): Key {
-		$uid = $user->getUID();
-		return $this->retrieveKey('user-' . $uid);
-	}
-
-	/**
-	 * Set public key for $user
-	 */
-	public function setPublicKey(IUser $user, string $publicKey): void {
-		$id = 'user-' . $user->getUID();
-
-		$folder = $this->appData->getFolder($id);
-		$folder->newFile('public', $publicKey);
-
-		$this->cache->set($id . '-public', $publicKey);
-	}
-
-	/**
-	 * Get instance wide public and private key
-	 *
-	 * @throws \RuntimeException
-	 */
-	public function getSystemKey(): Key {
-		$instanceId = $this->config->getSystemValue('instanceid', null);
-		if ($instanceId === null) {
-			throw new \RuntimeException('no instance id!');
-		}
-		return $this->retrieveKey('system-' . $instanceId);
-	}
-
-	public function hasAppKey(string $app, string $name): bool {
-		$id = $this->generateAppKeyId($app, $name);
-		try {
-			$folder = $this->appData->getFolder($id);
-			return ($folder->fileExists('public') && $folder->fileExists('private'));
-		} catch (NotFoundException) {
-			return false;
-		}
-	}
-
-	public function getAppKey(string $app, string $name): Key {
-		return $this->retrieveKey($this->generateAppKeyId($app, $name));
-	}
-
-	public function generateAppKey(string $app, string $name, array $options = []): Key {
-		return $this->generateKey($this->generateAppKeyId($app, $name), $options);
-	}
-
-	public function deleteAppKey(string $app, string $name): bool {
-		try {
-			$folder = $this->appData->getFolder($this->generateAppKeyId($app, $name));
-			$folder->delete();
-			return true;
-		} catch (NotFoundException) {
-			return false;
-		}
-	}
-
-	private function generateAppKeyId(string $app, string $name): string {
-		return 'app-' . $app . '-' . $name;
-	}
-
-	private function logOpensslError(): void {
-		$errors = [];
-		while ($error = openssl_error_string()) {
-			$errors[] = $error;
-		}
-		$this->logger->critical('Something is wrong with your openssl setup: ' . implode(', ', $errors));
-	}
+    private IAppData $appData;
+
+    protected ICache $cache;
+
+    public function __construct(
+        Factory $appDataFactory,
+        private ICrypto $crypto,
+        private IConfig $config,
+        private LoggerInterface $logger,
+        private ICacheFactory $cacheFactory,
+    ) {
+        $this->appData = $appDataFactory->get('identityproof');
+        $this->cache = $this->cacheFactory->createDistributed('identityproof::');
+    }
+
+    /**
+     * Calls the openssl functions to generate a public and private key.
+     * In a separate function for unit testing purposes.
+     *
+     * @param array $options config options to generate key {@see openssl_csr_new}
+     *
+     * @return array [$publicKey, $privateKey]
+     * @throws \RuntimeException
+     */
+    protected function generateKeyPair(array $options = []): array {
+        $config = [
+            'digest_alg' => $options['algorithm'] ?? 'sha512',
+            'private_key_bits' => $options['bits'] ?? 2048,
+            'private_key_type' => $options['type'] ?? OPENSSL_KEYTYPE_RSA,
+        ];
+
+        // Generate new key
+        $res = openssl_pkey_new($config);
+        if ($res === false) {
+            $this->logOpensslError();
+            throw new \RuntimeException('OpenSSL reported a problem');
+        }
+
+        if (openssl_pkey_export($res, $privateKey, null, $config) === false) {
+            $this->logOpensslError();
+            throw new \RuntimeException('OpenSSL reported a problem');
+        }
+
+        // Extract the public key from $res to $pubKey
+        $publicKey = openssl_pkey_get_details($res);
+        $publicKey = $publicKey['key'];
+
+        return [$publicKey, $privateKey];
+    }
+
+    /**
+     * Generate a key for a given ID
+     * Note: If a key already exists it will be overwritten
+     *
+     * @param string $id key id
+     * @param array $options config options to generate key {@see openssl_csr_new}
+     *
+     * @throws \RuntimeException
+     */
+    protected function generateKey(string $id, array $options = []): Key {
+        [$publicKey, $privateKey] = $this->generateKeyPair($options);
+
+        // Write the private and public key to the disk
+        try {
+            $this->appData->newFolder($id);
+        } catch (\Exception) {
+        }
+        $folder = $this->appData->getFolder($id);
+        $folder->newFile('private')
+            ->putContent($this->crypto->encrypt($privateKey));
+        $folder->newFile('public')
+            ->putContent($publicKey);
+
+        return new Key($publicKey, $privateKey);
+    }
+
+    /**
+     * Get key for a specific id
+     *
+     * @throws \RuntimeException
+     */
+    protected function retrieveKey(string $id): Key {
+        try {
+            $cachedPublicKey = $this->cache->get($id . '-public');
+            $cachedPrivateKey = $this->cache->get($id . '-private');
+
+            if ($cachedPublicKey !== null && $cachedPrivateKey !== null) {
+                $decryptedPrivateKey = $this->crypto->decrypt($cachedPrivateKey);
+
+                return new Key($cachedPublicKey, $decryptedPrivateKey);
+            }
+
+            $folder = $this->appData->getFolder($id);
+            $privateKey = $folder->getFile('private')->getContent();
+            $publicKey = $folder->getFile('public')->getContent();
+
+            $this->cache->set($id . '-public', $publicKey);
+            $this->cache->set($id . '-private', $privateKey);
+
+            $decryptedPrivateKey = $this->crypto->decrypt($privateKey);
+            return new Key($publicKey, $decryptedPrivateKey);
+        } catch (\Exception $e) {
+            return $this->generateKey($id);
+        }
+    }
+
+    /**
+     * Get public and private key for $user
+     *
+     * @throws \RuntimeException
+     */
+    public function getKey(IUser $user): Key {
+        $uid = $user->getUID();
+        return $this->retrieveKey('user-' . $uid);
+    }
+
+    /**
+     * Set public key for $user
+     */
+    public function setPublicKey(IUser $user, string $publicKey): void {
+        $id = 'user-' . $user->getUID();
+
+        $folder = $this->appData->getFolder($id);
+        $folder->newFile('public', $publicKey);
+
+        $this->cache->set($id . '-public', $publicKey);
+    }
+
+    /**
+     * Get instance wide public and private key
+     *
+     * @throws \RuntimeException
+     */
+    public function getSystemKey(): Key {
+        $instanceId = $this->config->getSystemValue('instanceid', null);
+        if ($instanceId === null) {
+            throw new \RuntimeException('no instance id!');
+        }
+        return $this->retrieveKey('system-' . $instanceId);
+    }
+
+    public function hasAppKey(string $app, string $name): bool {
+        $id = $this->generateAppKeyId($app, $name);
+        try {
+            $folder = $this->appData->getFolder($id);
+            return ($folder->fileExists('public') && $folder->fileExists('private'));
+        } catch (NotFoundException) {
+            return false;
+        }
+    }
+
+    public function getAppKey(string $app, string $name): Key {
+        return $this->retrieveKey($this->generateAppKeyId($app, $name));
+    }
+
+    public function generateAppKey(string $app, string $name, array $options = []): Key {
+        return $this->generateKey($this->generateAppKeyId($app, $name), $options);
+    }
+
+    public function deleteAppKey(string $app, string $name): bool {
+        try {
+            $folder = $this->appData->getFolder($this->generateAppKeyId($app, $name));
+            $folder->delete();
+            return true;
+        } catch (NotFoundException) {
+            return false;
+        }
+    }
+
+    private function generateAppKeyId(string $app, string $name): string {
+        return 'app-' . $app . '-' . $name;
+    }
+
+    private function logOpensslError(): void {
+        $errors = [];
+        while ($error = openssl_error_string()) {
+            $errors[] = $error;
+        }
+        $this->logger->critical('Something is wrong with your openssl setup: ' . implode(', ', $errors));
+    }
 }

Spacing +10 added lines, -10 removed lines

@@ -102,8 +102,8 @@ 
 	 */
 	protected function retrieveKey(string $id): Key {
 		try {
-			$cachedPublicKey = $this->cache->get($id . '-public');
-			$cachedPrivateKey = $this->cache->get($id . '-private');
+			$cachedPublicKey = $this->cache->get($id.'-public');
+			$cachedPrivateKey = $this->cache->get($id.'-private');
 
 			if ($cachedPublicKey !== null && $cachedPrivateKey !== null) {
 				$decryptedPrivateKey = $this->crypto->decrypt($cachedPrivateKey);
@@ -115,8 +115,8 @@ 
 			$privateKey = $folder->getFile('private')->getContent();
 			$publicKey = $folder->getFile('public')->getContent();
 
-			$this->cache->set($id . '-public', $publicKey);
-			$this->cache->set($id . '-private', $privateKey);
+			$this->cache->set($id.'-public', $publicKey);
+			$this->cache->set($id.'-private', $privateKey);
 
 			$decryptedPrivateKey = $this->crypto->decrypt($privateKey);
 			return new Key($publicKey, $decryptedPrivateKey);
@@ -132,19 +132,19 @@ 
 	 */
 	public function getKey(IUser $user): Key {
 		$uid = $user->getUID();
-		return $this->retrieveKey('user-' . $uid);
+		return $this->retrieveKey('user-'.$uid);
 	}
 
 	/**
 	 * Set public key for $user
 	 */
 	public function setPublicKey(IUser $user, string $publicKey): void {
-		$id = 'user-' . $user->getUID();
+		$id = 'user-'.$user->getUID();
 
 		$folder = $this->appData->getFolder($id);
 		$folder->newFile('public', $publicKey);
 
-		$this->cache->set($id . '-public', $publicKey);
+		$this->cache->set($id.'-public', $publicKey);
 	}
 
 	/**
@@ -157,7 +157,7 @@ 
 		if ($instanceId === null) {
 			throw new \RuntimeException('no instance id!');
 		}
-		return $this->retrieveKey('system-' . $instanceId);
+		return $this->retrieveKey('system-'.$instanceId);
 	}
 
 	public function hasAppKey(string $app, string $name): bool {
@@ -189,7 +189,7 @@ 
 	}
 
 	private function generateAppKeyId(string $app, string $name): string {
-		return 'app-' . $app . '-' . $name;
+		return 'app-'.$app.'-'.$name;
 	}
 
 	private function logOpensslError(): void {
@@ -197,6 +197,6 @@ 
 		while ($error = openssl_error_string()) {
 			$errors[] = $error;
 		}
-		$this->logger->critical('Something is wrong with your openssl setup: ' . implode(', ', $errors));
+		$this->logger->critical('Something is wrong with your openssl setup: '.implode(', ', $errors));
 	}
 }

core/Command/User/Keys/Verify.php

Indentation +73 added lines, -73 removed lines

@@ -19,77 +19,77 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Verify extends Command {
-	public function __construct(
-		protected IUserManager $userManager,
-		protected Manager $keyManager,
-	) {
-		parent::__construct();
-	}
-
-	protected function configure(): void {
-		$this
-			->setName('user:keys:verify')
-			->setDescription('Verify if the stored public key matches the stored private key')
-			->addArgument(
-				'user-id',
-				InputArgument::REQUIRED,
-				'User ID of the user to verify'
-			)
-			->addOption(
-				'update',
-				null,
-				InputOption::VALUE_NONE,
-				'Save the derived public key to match the private key'
-			)
-		;
-	}
-
-	/**
-	 * @param InputInterface $input
-	 * @param OutputInterface $output
-	 * @return int
-	 */
-	protected function execute(InputInterface $input, OutputInterface $output): int {
-		$userId = $input->getArgument('user-id');
-
-		$user = $this->userManager->get($userId);
-		if (!$user instanceof IUser) {
-			$output->writeln('Unknown user');
-			return static::FAILURE;
-		}
-
-		$key = $this->keyManager->getKey($user);
-		$publicKey = $key->getPublic();
-		$privateKey = $key->getPrivate();
-
-		$output->writeln('User public key size: ' . strlen($publicKey));
-		$output->writeln('User private key size: ' . strlen($privateKey));
-
-		// Derive the public key from the private key again to validate the stored public key
-		$opensslPrivateKey = openssl_pkey_get_private($privateKey);
-		$publicKeyDerived = openssl_pkey_get_details($opensslPrivateKey);
-		$publicKeyDerived = $publicKeyDerived['key'];
-		$output->writeln('User derived public key size: ' . strlen($publicKeyDerived));
-
-		$output->writeln('');
-
-		$output->writeln('Stored public key:');
-		$output->writeln($publicKey);
-		$output->writeln('Derived public key:');
-		$output->writeln($publicKeyDerived);
-
-		if ($publicKey != $publicKeyDerived) {
-			if (!$input->getOption('update')) {
-				$output->writeln('<error>Stored public key does not match stored private key</error>');
-				return static::FAILURE;
-			}
-
-			$this->keyManager->setPublicKey($user, $publicKeyDerived);
-			$output->writeln('<info>Derived public key did not match, successfully updated</info>');
-			return static::SUCCESS;
-		}
-
-		$output->writeln('<info>Stored public key matches stored private key</info>');
-		return static::SUCCESS;
-	}
+    public function __construct(
+        protected IUserManager $userManager,
+        protected Manager $keyManager,
+    ) {
+        parent::__construct();
+    }
+
+    protected function configure(): void {
+        $this
+            ->setName('user:keys:verify')
+            ->setDescription('Verify if the stored public key matches the stored private key')
+            ->addArgument(
+                'user-id',
+                InputArgument::REQUIRED,
+                'User ID of the user to verify'
+            )
+            ->addOption(
+                'update',
+                null,
+                InputOption::VALUE_NONE,
+                'Save the derived public key to match the private key'
+            )
+        ;
+    }
+
+    /**
+     * @param InputInterface $input
+     * @param OutputInterface $output
+     * @return int
+     */
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        $userId = $input->getArgument('user-id');
+
+        $user = $this->userManager->get($userId);
+        if (!$user instanceof IUser) {
+            $output->writeln('Unknown user');
+            return static::FAILURE;
+        }
+
+        $key = $this->keyManager->getKey($user);
+        $publicKey = $key->getPublic();
+        $privateKey = $key->getPrivate();
+
+        $output->writeln('User public key size: ' . strlen($publicKey));
+        $output->writeln('User private key size: ' . strlen($privateKey));
+
+        // Derive the public key from the private key again to validate the stored public key
+        $opensslPrivateKey = openssl_pkey_get_private($privateKey);
+        $publicKeyDerived = openssl_pkey_get_details($opensslPrivateKey);
+        $publicKeyDerived = $publicKeyDerived['key'];
+        $output->writeln('User derived public key size: ' . strlen($publicKeyDerived));
+
+        $output->writeln('');
+
+        $output->writeln('Stored public key:');
+        $output->writeln($publicKey);
+        $output->writeln('Derived public key:');
+        $output->writeln($publicKeyDerived);
+
+        if ($publicKey != $publicKeyDerived) {
+            if (!$input->getOption('update')) {
+                $output->writeln('<error>Stored public key does not match stored private key</error>');
+                return static::FAILURE;
+            }
+
+            $this->keyManager->setPublicKey($user, $publicKeyDerived);
+            $output->writeln('<info>Derived public key did not match, successfully updated</info>');
+            return static::SUCCESS;
+        }
+
+        $output->writeln('<info>Stored public key matches stored private key</info>');
+        return static::SUCCESS;
+    }
 }

tests/lib/Security/IdentityProof/ManagerTest.php

Indentation +247 added lines, -247 removed lines

@@ -26,251 +26,251 @@
 use Test\TestCase;
 
 class ManagerTest extends TestCase {
-	private Factory&MockObject $factory;
-	private IAppData&MockObject $appData;
-	private ICrypto&MockObject $crypto;
-	private Manager&MockObject $manager;
-	private IConfig&MockObject $config;
-	private LoggerInterface&MockObject $logger;
-	private ICacheFactory&MockObject $cacheFactory;
-	private ICache&MockObject $cache;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		/** @var Factory|\PHPUnit\Framework\MockObject\MockObject $factory */
-		$this->factory = $this->createMock(Factory::class);
-		$this->appData = $this->createMock(AppData::class);
-		$this->config = $this->createMock(IConfig::class);
-		$this->factory->expects($this->any())
-			->method('get')
-			->with('identityproof')
-			->willReturn($this->appData);
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->cacheFactory = $this->createMock(ICacheFactory::class);
-		$this->cache = $this->createMock(ICache::class);
-
-		$this->cacheFactory->expects($this->any())
-			->method('createDistributed')
-			->willReturn($this->cache);
-
-		$this->crypto = $this->createMock(ICrypto::class);
-		$this->manager = $this->getManager(['generateKeyPair']);
-	}
-
-	/**
-	 * create manager object
-	 *
-	 * @param array $setMethods
-	 * @return Manager|\PHPUnit\Framework\MockObject\MockObject
-	 */
-	protected function getManager($setMethods = []) {
-		if (empty($setMethods)) {
-			return new Manager(
-				$this->factory,
-				$this->crypto,
-				$this->config,
-				$this->logger,
-				$this->cacheFactory,
-			);
-		} else {
-			return $this->getMockBuilder(Manager::class)
-				->setConstructorArgs([
-					$this->factory,
-					$this->crypto,
-					$this->config,
-					$this->logger,
-					$this->cacheFactory,
-				])
-				->onlyMethods($setMethods)
-				->getMock();
-		}
-	}
-
-	public function testGetKeyWithExistingKey(): void {
-		$user = $this->createMock(IUser::class);
-		$user
-			->expects($this->once())
-			->method('getUID')
-			->willReturn('MyUid');
-		$folder = $this->createMock(ISimpleFolder::class);
-		$privateFile = $this->createMock(ISimpleFile::class);
-		$privateFile
-			->expects($this->once())
-			->method('getContent')
-			->willReturn('EncryptedPrivateKey');
-		$publicFile = $this->createMock(ISimpleFile::class);
-		$publicFile
-			->expects($this->once())
-			->method('getContent')
-			->willReturn('MyPublicKey');
-		$this->crypto
-			->expects($this->once())
-			->method('decrypt')
-			->with('EncryptedPrivateKey')
-			->willReturn('MyPrivateKey');
-		$folder
-			->expects($this->exactly(2))
-			->method('getFile')
-			->willReturnMap([
-				['private', $privateFile],
-				['public', $publicFile],
-			]);
-		$this->appData
-			->expects($this->once())
-			->method('getFolder')
-			->with('user-MyUid')
-			->willReturn($folder);
-		$this->cache
-			->expects($this->exactly(2))
-			->method('get')
-			->willReturn(null);
-
-		$expected = new Key('MyPublicKey', 'MyPrivateKey');
-		$this->assertEquals($expected, $this->manager->getKey($user));
-	}
-
-	public function testGetKeyWithExistingKeyCached(): void {
-		$user = $this->createMock(IUser::class);
-		$user
-			->expects($this->once())
-			->method('getUID')
-			->willReturn('MyUid');
-		$this->crypto
-			->expects($this->once())
-			->method('decrypt')
-			->with('EncryptedPrivateKey')
-			->willReturn('MyPrivateKey');
-		$this->cache
-			->expects($this->exactly(2))
-			->method('get')
-			->willReturnMap([
-				['user-MyUid-public', 'MyPublicKey'],
-				['user-MyUid-private', 'EncryptedPrivateKey'],
-			]);
-
-		$expected = new Key('MyPublicKey', 'MyPrivateKey');
-		$this->assertEquals($expected, $this->manager->getKey($user));
-	}
-
-	public function testSetPublicKey(): void {
-		$user = $this->createMock(IUser::class);
-		$user
-			->expects($this->exactly(1))
-			->method('getUID')
-			->willReturn('MyUid');
-		$publicFile = $this->createMock(ISimpleFile::class);
-		$folder = $this->createMock(ISimpleFolder::class);
-		$folder
-			->expects($this->once())
-			->method('newFile')
-			->willReturnMap([
-				['public', 'MyNewPublicKey', $publicFile],
-			]);
-		$this->appData
-			->expects($this->once())
-			->method('getFolder')
-			->with('user-MyUid')
-			->willReturn($folder);
-		$this->cache
-			->expects($this->once())
-			->method('set')
-			->with('user-MyUid-public', 'MyNewPublicKey');
-
-		$this->manager->setPublicKey($user, 'MyNewPublicKey');
-	}
-
-	public function testGetKeyWithNotExistingKey(): void {
-		$user = $this->createMock(IUser::class);
-		$user
-			->expects($this->once())
-			->method('getUID')
-			->willReturn('MyUid');
-		$this->manager
-			->expects($this->once())
-			->method('generateKeyPair')
-			->willReturn(['MyNewPublicKey', 'MyNewPrivateKey']);
-		$this->appData
-			->expects($this->once())
-			->method('newFolder')
-			->with('user-MyUid');
-		$folder = $this->createMock(ISimpleFolder::class);
-		$this->crypto
-			->expects($this->once())
-			->method('encrypt')
-			->with('MyNewPrivateKey')
-			->willReturn('MyNewEncryptedPrivateKey');
-		$privateFile = $this->createMock(ISimpleFile::class);
-		$privateFile
-			->expects($this->once())
-			->method('putContent')
-			->with('MyNewEncryptedPrivateKey');
-		$publicFile = $this->createMock(ISimpleFile::class);
-		$publicFile
-			->expects($this->once())
-			->method('putContent')
-			->with('MyNewPublicKey');
-		$folder
-			->expects($this->exactly(2))
-			->method('newFile')
-			->willReturnMap([
-				['private', null, $privateFile],
-				['public', null, $publicFile],
-			]);
-		$this->appData
-			->expects($this->exactly(2))
-			->method('getFolder')
-			->with('user-MyUid')
-			->willReturnOnConsecutiveCalls(
-				$this->throwException(new \Exception()),
-				$folder
-			);
-
-
-		$expected = new Key('MyNewPublicKey', 'MyNewPrivateKey');
-		$this->assertEquals($expected, $this->manager->getKey($user));
-	}
-
-	public function testGenerateKeyPair(): void {
-		$manager = $this->getManager();
-		$data = 'MyTestData';
-
-		[$resultPublicKey, $resultPrivateKey] = self::invokePrivate($manager, 'generateKeyPair');
-		openssl_sign($data, $signature, $resultPrivateKey);
-		$details = openssl_pkey_get_details(openssl_pkey_get_public($resultPublicKey));
-
-		$this->assertSame(1, openssl_verify($data, $signature, $resultPublicKey));
-		$this->assertSame(2048, $details['bits']);
-	}
-
-	public function testGetSystemKey(): void {
-		$manager = $this->getManager(['retrieveKey']);
-
-		/** @var Key|\PHPUnit\Framework\MockObject\MockObject $key */
-		$key = $this->createMock(Key::class);
-
-		$this->config->expects($this->once())->method('getSystemValue')
-			->with('instanceid', null)->willReturn('instanceId');
-
-		$manager->expects($this->once())->method('retrieveKey')->with('system-instanceId')
-			->willReturn($key);
-
-		$this->assertSame($key, $manager->getSystemKey());
-	}
-
-
-
-	public function testGetSystemKeyFailure(): void {
-		$this->expectException(\RuntimeException::class);
-
-		$manager = $this->getManager(['retrieveKey']);
-
-		/** @var Key|\PHPUnit\Framework\MockObject\MockObject $key */
-		$key = $this->createMock(Key::class);
-
-		$this->config->expects($this->once())->method('getSystemValue')
-			->with('instanceid', null)->willReturn(null);
-
-		$manager->getSystemKey();
-	}
+    private Factory&MockObject $factory;
+    private IAppData&MockObject $appData;
+    private ICrypto&MockObject $crypto;
+    private Manager&MockObject $manager;
+    private IConfig&MockObject $config;
+    private LoggerInterface&MockObject $logger;
+    private ICacheFactory&MockObject $cacheFactory;
+    private ICache&MockObject $cache;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        /** @var Factory|\PHPUnit\Framework\MockObject\MockObject $factory */
+        $this->factory = $this->createMock(Factory::class);
+        $this->appData = $this->createMock(AppData::class);
+        $this->config = $this->createMock(IConfig::class);
+        $this->factory->expects($this->any())
+            ->method('get')
+            ->with('identityproof')
+            ->willReturn($this->appData);
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->cacheFactory = $this->createMock(ICacheFactory::class);
+        $this->cache = $this->createMock(ICache::class);
+
+        $this->cacheFactory->expects($this->any())
+            ->method('createDistributed')
+            ->willReturn($this->cache);
+
+        $this->crypto = $this->createMock(ICrypto::class);
+        $this->manager = $this->getManager(['generateKeyPair']);
+    }
+
+    /**
+     * create manager object
+     *
+     * @param array $setMethods
+     * @return Manager|\PHPUnit\Framework\MockObject\MockObject
+     */
+    protected function getManager($setMethods = []) {
+        if (empty($setMethods)) {
+            return new Manager(
+                $this->factory,
+                $this->crypto,
+                $this->config,
+                $this->logger,
+                $this->cacheFactory,
+            );
+        } else {
+            return $this->getMockBuilder(Manager::class)
+                ->setConstructorArgs([
+                    $this->factory,
+                    $this->crypto,
+                    $this->config,
+                    $this->logger,
+                    $this->cacheFactory,
+                ])
+                ->onlyMethods($setMethods)
+                ->getMock();
+        }
+    }
+
+    public function testGetKeyWithExistingKey(): void {
+        $user = $this->createMock(IUser::class);
+        $user
+            ->expects($this->once())
+            ->method('getUID')
+            ->willReturn('MyUid');
+        $folder = $this->createMock(ISimpleFolder::class);
+        $privateFile = $this->createMock(ISimpleFile::class);
+        $privateFile
+            ->expects($this->once())
+            ->method('getContent')
+            ->willReturn('EncryptedPrivateKey');
+        $publicFile = $this->createMock(ISimpleFile::class);
+        $publicFile
+            ->expects($this->once())
+            ->method('getContent')
+            ->willReturn('MyPublicKey');
+        $this->crypto
+            ->expects($this->once())
+            ->method('decrypt')
+            ->with('EncryptedPrivateKey')
+            ->willReturn('MyPrivateKey');
+        $folder
+            ->expects($this->exactly(2))
+            ->method('getFile')
+            ->willReturnMap([
+                ['private', $privateFile],
+                ['public', $publicFile],
+            ]);
+        $this->appData
+            ->expects($this->once())
+            ->method('getFolder')
+            ->with('user-MyUid')
+            ->willReturn($folder);
+        $this->cache
+            ->expects($this->exactly(2))
+            ->method('get')
+            ->willReturn(null);
+
+        $expected = new Key('MyPublicKey', 'MyPrivateKey');
+        $this->assertEquals($expected, $this->manager->getKey($user));
+    }
+
+    public function testGetKeyWithExistingKeyCached(): void {
+        $user = $this->createMock(IUser::class);
+        $user
+            ->expects($this->once())
+            ->method('getUID')
+            ->willReturn('MyUid');
+        $this->crypto
+            ->expects($this->once())
+            ->method('decrypt')
+            ->with('EncryptedPrivateKey')
+            ->willReturn('MyPrivateKey');
+        $this->cache
+            ->expects($this->exactly(2))
+            ->method('get')
+            ->willReturnMap([
+                ['user-MyUid-public', 'MyPublicKey'],
+                ['user-MyUid-private', 'EncryptedPrivateKey'],
+            ]);
+
+        $expected = new Key('MyPublicKey', 'MyPrivateKey');
+        $this->assertEquals($expected, $this->manager->getKey($user));
+    }
+
+    public function testSetPublicKey(): void {
+        $user = $this->createMock(IUser::class);
+        $user
+            ->expects($this->exactly(1))
+            ->method('getUID')
+            ->willReturn('MyUid');
+        $publicFile = $this->createMock(ISimpleFile::class);
+        $folder = $this->createMock(ISimpleFolder::class);
+        $folder
+            ->expects($this->once())
+            ->method('newFile')
+            ->willReturnMap([
+                ['public', 'MyNewPublicKey', $publicFile],
+            ]);
+        $this->appData
+            ->expects($this->once())
+            ->method('getFolder')
+            ->with('user-MyUid')
+            ->willReturn($folder);
+        $this->cache
+            ->expects($this->once())
+            ->method('set')
+            ->with('user-MyUid-public', 'MyNewPublicKey');
+
+        $this->manager->setPublicKey($user, 'MyNewPublicKey');
+    }
+
+    public function testGetKeyWithNotExistingKey(): void {
+        $user = $this->createMock(IUser::class);
+        $user
+            ->expects($this->once())
+            ->method('getUID')
+            ->willReturn('MyUid');
+        $this->manager
+            ->expects($this->once())
+            ->method('generateKeyPair')
+            ->willReturn(['MyNewPublicKey', 'MyNewPrivateKey']);
+        $this->appData
+            ->expects($this->once())
+            ->method('newFolder')
+            ->with('user-MyUid');
+        $folder = $this->createMock(ISimpleFolder::class);
+        $this->crypto
+            ->expects($this->once())
+            ->method('encrypt')
+            ->with('MyNewPrivateKey')
+            ->willReturn('MyNewEncryptedPrivateKey');
+        $privateFile = $this->createMock(ISimpleFile::class);
+        $privateFile
+            ->expects($this->once())
+            ->method('putContent')
+            ->with('MyNewEncryptedPrivateKey');
+        $publicFile = $this->createMock(ISimpleFile::class);
+        $publicFile
+            ->expects($this->once())
+            ->method('putContent')
+            ->with('MyNewPublicKey');
+        $folder
+            ->expects($this->exactly(2))
+            ->method('newFile')
+            ->willReturnMap([
+                ['private', null, $privateFile],
+                ['public', null, $publicFile],
+            ]);
+        $this->appData
+            ->expects($this->exactly(2))
+            ->method('getFolder')
+            ->with('user-MyUid')
+            ->willReturnOnConsecutiveCalls(
+                $this->throwException(new \Exception()),
+                $folder
+            );
+
+
+        $expected = new Key('MyNewPublicKey', 'MyNewPrivateKey');
+        $this->assertEquals($expected, $this->manager->getKey($user));
+    }
+
+    public function testGenerateKeyPair(): void {
+        $manager = $this->getManager();
+        $data = 'MyTestData';
+
+        [$resultPublicKey, $resultPrivateKey] = self::invokePrivate($manager, 'generateKeyPair');
+        openssl_sign($data, $signature, $resultPrivateKey);
+        $details = openssl_pkey_get_details(openssl_pkey_get_public($resultPublicKey));
+
+        $this->assertSame(1, openssl_verify($data, $signature, $resultPublicKey));
+        $this->assertSame(2048, $details['bits']);
+    }
+
+    public function testGetSystemKey(): void {
+        $manager = $this->getManager(['retrieveKey']);
+
+        /** @var Key|\PHPUnit\Framework\MockObject\MockObject $key */
+        $key = $this->createMock(Key::class);
+
+        $this->config->expects($this->once())->method('getSystemValue')
+            ->with('instanceid', null)->willReturn('instanceId');
+
+        $manager->expects($this->once())->method('retrieveKey')->with('system-instanceId')
+            ->willReturn($key);
+
+        $this->assertSame($key, $manager->getSystemKey());
+    }
+
+
+
+    public function testGetSystemKeyFailure(): void {
+        $this->expectException(\RuntimeException::class);
+
+        $manager = $this->getManager(['retrieveKey']);
+
+        /** @var Key|\PHPUnit\Framework\MockObject\MockObject $key */
+        $key = $this->createMock(Key::class);
+
+        $this->config->expects($this->once())->method('getSystemValue')
+            ->with('instanceid', null)->willReturn(null);
+
+        $manager->getSystemKey();
+    }
 }