fix(files): carry the unencrypted size over when copying a cache entry

The size of an encrypted file lives in `unencrypted_size`, and both
CacheEntry::getUnencryptedSize() and FileInfo::getSize() prefer it over
`size`. Cache::copyFromCache() copied the `encrypted` mark without it, so
the copy of an encrypted file was marked encrypted with an unencrypted size
of 0 and reported as empty - in the web UI, to clients and for quota - until
something rescanned it.

Copy the unencrypted size alongside the encrypted version, and reset it when
the mark is dropped for a target that is not encrypted, where the size is
read from `size`.

Assisted-by: ClaudeCode:claude-opus-5
Signed-off-by: Ferdinand Thiessen <opensource@fthiessen.de>

Author: susnux

apps/encryption/tests/CopySizeTest.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\encryption\tests;
+
+use OC\Files\Storage\Temporary;
+use OC\Files\View;
+use OCA\Encryption\KeyManager;
+use OCP\Server;
+use Test\TestCase;
+use Test\Traits\EncryptionTrait;
+use Test\Traits\MountProviderTrait;
+use Test\Traits\UserTrait;
+
+/**
+ * The size of an encrypted file is kept in `unencrypted_size`, which every reader
+ * prefers over `size`. A copy has to carry it over, otherwise the copy is reported
+ * as empty.
+ */
+#[\PHPUnit\Framework\Attributes\Group(name: 'DB')]
+class CopySizeTest extends TestCase {
+	use MountProviderTrait;
+	use EncryptionTrait;
+	use UserTrait;
+
+	private function setUpView(): View {
+		Server::get(KeyManager::class)->validateMasterKey();
+		Server::get(KeyManager::class)->validateShareKey();
+		$this->createUser('test1', 'test2');
+		$this->setupForUser('test1', 'test2');
+		$this->registerMount('test1', new Temporary(), '/test1/files/other');
+		$this->loginWithEncryption('test1');
+
+		return new View('/test1/files');
+	}
+
+	public function testCopyKeepsTheSize(): void {
+		$view = $this->setUpView();
+
+		$view->file_put_contents('source.bin', str_repeat('a', 20000));
+		$this->assertTrue($view->copy('source.bin', 'target.bin'));
+
+		$this->assertEquals(20000, $view->getFileInfo('target.bin')->getSize());
+	}
+
+	public function testCopyToAnotherStorageKeepsTheSize(): void {
+		$view = $this->setUpView();
+
+		$view->file_put_contents('source.bin', str_repeat('a', 20000));
+		$this->assertTrue($view->copy('source.bin', 'other/target.bin'));
+
+		$this->assertEquals(20000, $view->getFileInfo('other/target.bin')->getSize());
+	}
+
+	public function testCopyOfAFolderKeepsTheSizes(): void {
+		$view = $this->setUpView();
+
+		$view->mkdir('source');
+		$view->file_put_contents('source/file.bin', str_repeat('a', 20000));
+		$this->assertTrue($view->copy('source', 'target'));
+
+		$this->assertEquals(20000, $view->getFileInfo('target/file.bin')->getSize());
+		$this->assertEquals(20000, $view->getFileInfo('target')->getSize());
+	}
+}

build/integration/encryption_features/encryption.feature

@@ -26,6 +26,7 @@ Feature: encryption
     And User "user0" adds a file of 20000 bytes to "/big.bin"
     When User "user0" copies file "/big.bin" to "/copy.bin"
     Then the HTTP status code should be "201"
+    And File "/copy.bin" should have prop "d:getcontentlength" equal to "20000"
     When Downloading file "/copy.bin"
     Then the HTTP status code should be "200"
 

lib/private/Files/Cache/Cache.php

@@ -1281,6 +1281,8 @@ public function copyFromCache(ICache $sourceCache, ICacheEntry $sourceEntry, str
 			// normalizeData() prefers 'encryptedVersion' over 'encrypted' when both are
 			// set, so it has to be cleared too or the mark above gets ignored
 			unset($data['encryptedVersion']);
+			// without the `encrypted` mark the size of the copy is read from `size`
+			$data['unencrypted_size'] = 0;
 		} elseif (isset($data['encryptedVersion'])) {
 			// The storage re-encrypts the content it writes to the target, so the target
 			// is at its own version - the one recorded for it while it was written - and
@@ -1323,8 +1325,14 @@ private function cacheEntryToArray(ICacheEntry $entry): array {
 			$data['permissions'] = $entry['scan_permissions'];
 		}
 
-		if ($entry->isEncrypted() && isset($entry['encryptedVersion'])) {
-			$data['encryptedVersion'] = $entry['encryptedVersion'];
+		if ($entry->isEncrypted()) {
+			// the size of an encrypted file is stored in its own column, which every
+			// reader prefers over `size`, so the copy is reported as empty without it
+			$data['unencrypted_size'] = $entry->getUnencryptedSize();
+
+			if (isset($entry['encryptedVersion'])) {
+				$data['encryptedVersion'] = $entry['encryptedVersion'];
+			}
 		}
 
 		return $data;

tests/lib/Files/Cache/CacheTest.php

@@ -726,10 +726,25 @@ public function testCopyFromCachePreservesEncryptedVersion(): void {
 		$this->assertSame(3, $targetEntry['encryptedVersion']);
 	}
 
+	public function testCopyFromCachePreservesUnencryptedSize(): void {
+		$data = [
+			'size' => 128, 'mtime' => 50, 'mimetype' => 'foo/bar',
+			'encrypted' => true, 'encryptedVersion' => 3, 'unencrypted_size' => 100,
+		];
+		$this->cache->put('source', $data);
+		$sourceEntry = $this->cache->get('source');
+		$this->assertEquals(100, $sourceEntry->getUnencryptedSize());
+
+		$this->cache->copyFromCache($this->cache, $sourceEntry, 'target');
+
+		$targetEntry = $this->cache->get('target');
+		$this->assertEquals(100, $targetEntry->getUnencryptedSize());
+	}
+
 	public function testCopyFromCacheClearsEncryptedVersionWhenCopyingToNonEncryptedStorage(): void {
 		$data = [
-			'size' => 100, 'mtime' => 50, 'mimetype' => 'foo/bar',
-			'encrypted' => true, 'encryptedVersion' => 3,
+			'size' => 128, 'mtime' => 50, 'mimetype' => 'foo/bar',
+			'encrypted' => true, 'encryptedVersion' => 3, 'unencrypted_size' => 100,
 		];
 		$this->cache2->put('source', $data);
 		$sourceEntry = $this->cache2->get('source');
@@ -751,6 +766,9 @@ public function testCopyFromCacheClearsEncryptedVersionWhenCopyingToNonEncrypted
 		$targetEntry = $targetCache->get('target');
 		$this->assertFalse($targetEntry->isEncrypted());
 		$this->assertSame(0, $targetEntry['encryptedVersion']);
+		// the target is not marked as encrypted, so its size is read from `size`
+		$this->assertEquals(0, $targetEntry['unencrypted_size']);
+		$this->assertEquals(128, $targetEntry->getSize());
 	}
 
 	public function testGetIncomplete(): void {