fix(encryption): Address review feedback and fix zero-byte size consistency

Apply come-nc's reviewer suggestions on Scanner.php:
- Simplify cached unencrypted_size skip condition to explicit == 0 check
- Remove redundant !isset guard on new-file path

Fix remaining > 0 / !== 0 guards that treated zero as "no unencrypted_size":
- FileInfo constructor: use encrypted flag for rawSize (getSize(false) path)
- FileInfo::addSubEntry: use encrypted flag for sub-mount accumulation
- Cache::calculateFolderSizeInner: use encrypted column instead of > 0

Add tests covering zero-byte encrypted file scenarios:
- FileInfoTest: getSize(true/false) for zero-byte encrypted files
- CacheTest: getUnencryptedSize and calculateFolderSize with encrypted=1,size=0
- EncryptionTest: verifyUnencryptedSize data provider cases for header-only files

Assisted-by: ClaudeCode:claude-opus-4-6
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Signed-off-by: Stephen Cuppett <scuppett@redhat.com>

Author: 2 people

lib/private/Files/Cache/Cache.php

@@ -1043,7 +1043,7 @@ protected function calculateFolderSizeInner(string $path, $entry = null, bool $i
 			$id = $entry['fileid'];
 
 			$query = $this->getQueryBuilder();
-			$query->select('size', 'unencrypted_size')
+			$query->select('size', 'unencrypted_size', 'encrypted')
 				->from('filecache')
 				->whereStorageId($this->getNumericStorageId())
 				->whereParent($id);
@@ -1063,7 +1063,7 @@ protected function calculateFolderSizeInner(string $path, $entry = null, bool $i
 					return Util::numericToNumber($row['unencrypted_size']);
 				}, $rows);
 				$unencryptedSizes = array_map(function (array $row) {
-					return Util::numericToNumber(($row['unencrypted_size'] > 0) ? $row['unencrypted_size'] : $row['size']);
+					return Util::numericToNumber($row['encrypted'] ? $row['unencrypted_size'] : $row['size']);
 				}, $rows);
 
 				$sum = array_sum($sizes);

lib/private/Files/Cache/Scanner.php

@@ -183,12 +183,10 @@ public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData =
 						}
 					}
 
-					// Only skip updating unencrypted_size if both cached and new values are 0
-					// This allows updating from incorrect cached 0 to correct non-zero value
-					// while avoiding unnecessary updates when both are legitimately 0
+					// Skip updating unencrypted_size only when both cached and new values are 0
 					if (isset($cacheData['unencrypted_size'])
 						&& $cacheData['unencrypted_size'] === 0
-						&& (!isset($data['unencrypted_size']) || $data['unencrypted_size'] === 0)) {
+						&& isset($data['unencrypted_size']) && $data['unencrypted_size'] === 0) {
 						unset($data['unencrypted_size']);
 					}
 
@@ -206,10 +204,8 @@ public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData =
 						$data['etag_changed'] = true;
 					}
 				} else {
-					// For new files, preserve unencrypted_size only when the file is encrypted
-					// and the key is present; otherwise clear it so it won't be written stale.
-					if (!isset($data['encrypted']) || !$data['encrypted']
-						|| !isset($data['unencrypted_size'])) {
+					// For new files, only preserve unencrypted_size when the file is encrypted
+					if (!isset($data['encrypted']) || !$data['encrypted']) {
 						unset($data['unencrypted_size']);
 					}
 					$newData = $data;

lib/private/Files/FileInfo.php

@@ -58,7 +58,7 @@ public function __construct(
 		private ?IUser $owner = null,
 	) {
 		$this->mount = $mount;
-		if (isset($this->data['unencrypted_size']) && $this->data['unencrypted_size'] !== 0) {
+		if (($this->data['encrypted'] ?? false) && isset($this->data['unencrypted_size'])) {
 			$this->rawSize = $this->data['unencrypted_size'];
 		} else {
 			$this->rawSize = $this->data['size'] ?? 0;
@@ -355,7 +355,7 @@ public function addSubEntry($data, $entryPath) {
 		if (!$data) {
 			return;
 		}
-		$hasUnencryptedSize = isset($data['unencrypted_size']) && $data['unencrypted_size'] > 0;
+		$hasUnencryptedSize = !empty($data['encrypted']) && isset($data['unencrypted_size']);
 		if ($hasUnencryptedSize) {
 			$subSize = $data['unencrypted_size'];
 		} else {

tests/lib/Files/Cache/CacheTest.php

@@ -153,6 +153,16 @@ public function testCacheEntryGetters(): void {
 		$this->assertEquals($entry->getUnencryptedSize(), 100);
 	}
 
+	public function testGetUnencryptedSizeEncryptedZeroByte(): void {
+		$file1 = 'encrypted_zero';
+		$this->cache->put($file1, ['size' => 8192, 'mtime' => 50, 'mimetype' => 'application/octet-stream', 'encrypted' => 1, 'unencrypted_size' => 0]);
+		$entry = $this->cache->get($file1);
+
+		// getUnencryptedSize() must return 0 (the true plaintext size), not 8192 (the encrypted on-disk size)
+		$this->assertEquals(0, $entry->getUnencryptedSize());
+		$this->assertTrue($entry->isEncrypted());
+	}
+
 	public function testPartial(): void {
 		$file1 = 'foo';
 
@@ -292,6 +302,28 @@ public function testEncryptedFolder(): void {
 		$this->assertFalse($this->cache->inCache('folder/bar'));
 	}
 
+	public function testCalculateFolderSizeWithEncryptedZeroByte(): void {
+		$folder = 'enc_folder';
+		$this->cache->put($folder, ['size' => -1, 'mtime' => 20, 'mimetype' => ICacheEntry::DIRECTORY_MIMETYPE]);
+
+		// Child: a zero-byte encrypted file — on-disk size is 8192 (header), but plaintext is 0
+		$child = $folder . '/empty.enc';
+		$this->cache->put($child, [
+			'size' => 8192,
+			'mtime' => 20,
+			'mimetype' => 'application/octet-stream',
+			'encrypted' => 1,
+			'unencrypted_size' => 0,
+		]);
+
+		$folderSize = $this->cache->calculateFolderSize($folder);
+
+		// The folder's unencrypted_size must reflect the true plaintext total (0), not the encrypted on-disk size (8192)
+		$entry = $this->cache->get($folder);
+		$this->assertEquals(0, $entry['unencrypted_size'], 'Folder unencrypted_size should be 0 for zero-byte encrypted children');
+		$this->assertEquals(8192, $entry['size'], 'Folder size should equal encrypted on-disk size');
+	}
+
 	public function testRootFolderSizeForNonHomeStorage(): void {
 		$dir1 = 'knownsize';
 		$dir2 = 'unknownsize';

tests/lib/Files/FileInfoTest.php

@@ -29,6 +29,30 @@ protected function setUp(): void {
 		$this->config = $this->getMockBuilder(IConfig::class)->getMock();
 	}
 
+	private function makeFileInfo(array $data): FileInfo {
+		$storage = new Temporary();
+		return new FileInfo('', $storage, '', $data, new MountPoint($storage, '/foo/files'));
+	}
+
+	public function testGetSizeEncryptedZeroByte(): void {
+		$info = $this->makeFileInfo(['encrypted' => true, 'size' => 8192, 'unencrypted_size' => 0]);
+		// Both paths must report the true plaintext size (0), not the on-disk encrypted size (8192)
+		$this->assertSame(0, $info->getSize(true));
+		$this->assertSame(0, $info->getSize(false));
+	}
+
+	public function testGetSizeEncryptedNonZero(): void {
+		$info = $this->makeFileInfo(['encrypted' => true, 'size' => 16384, 'unencrypted_size' => 5000]);
+		$this->assertSame(5000, $info->getSize(true));
+		$this->assertSame(5000, $info->getSize(false));
+	}
+
+	public function testGetSizeNonEncrypted(): void {
+		$info = $this->makeFileInfo(['encrypted' => false, 'size' => 100]);
+		$this->assertSame(100, $info->getSize(true));
+		$this->assertSame(100, $info->getSize(false));
+	}
+
 	public function testIsMountedHomeStorage(): void {
 		$user = $this->createMock(IUser::class);
 		$user->method('getUID')

tests/lib/Files/Storage/Wrapper/EncryptionTest.php

@@ -387,7 +387,11 @@ public static function dataTestVerifyUnencryptedSize(): array {
 			[120, 80, false, 80],
 			[120, 120, false, 80],
 			[120, -1, false, 80],
-			[120, -1, true, -1]
+			[120, -1, true, -1],
+			// Zero-byte encrypted file: on-disk size equals header only (8192) — should NOT recalculate
+			[8192, 0, false, 0],
+			// Encrypted file with content beyond header but unencrypted_size=0 — SHOULD recalculate
+			[16384, 0, false, 80],
 		];
 	}