Skip to content

armgit / Filee

Public Imported from GitHub
0

Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.

Merge main into feat/linux-updater-2.0.0

KnifeLemone8d74f540820
diff --cc src/Filee.App/Services/UpdateService.cs
index 45a0459e,fa8382e1..53f14238
--- a/src/Filee.App/Services/UpdateService.cs
+++ b/src/Filee.App/Services/UpdateService.cs
@@@ -14,7 -12,7 +15,8 @@@ using System.Security.Cryptography
using System.Text.Json;
using Avalonia.Threading;
using CommunityToolkit.Mvvm.ComponentModel;
+using Filee.Core.Settings;
+ using Filee.Platform.Windows;
using Microsoft.Extensions.Logging;
namespace Filee.App.Services;
@@@ -332,139 -274,49 +343,141 @@@ public sealed partial class UpdateServi
return;
}
- string installer;
- try
+ if (TargetPlatform == "win")
{
- var progress = new Progress<int>(percent => DownloadPercent = percent);
- installer = await DownloadInstallerAsync(Path.Combine(Path.GetTempPath(), "Filee-update"), progress);
- // WinVerifyTrust hashes the whole installer and may ask the certificate authority about revocation.
- await Task.Run(() => CheckPublisher(installer));
- }
- catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or IOException
- or InvalidDataException or UnauthorizedAccessException)
- {
- Fail("download", ex);
- return;
- }
+ var folder = Path.Combine(Path.GetTempPath(), "Filee-update");
+ string installer;
+ try
+ {
+ var progress = new Progress<int>(percent => DownloadPercent = percent);
+ installer = await DownloadInstallerAsync(folder, progress);
++ // WinVerifyTrust hashes the whole installer and may ask the certificate authority about revocation.
++ await Task.Run(() => CheckPublisher(installer));
+ }
+ catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or IOException
+ or InvalidDataException or UnauthorizedAccessException)
+ {
+ Fail("download", ex);
+ return;
+ }
- Process? setup;
- try
- {
- setup = Process.Start(new ProcessStartInfo(installer, InstallerArguments) { UseShellExecute = true });
- }
- catch (Win32Exception ex) when (ex.NativeErrorCode == ErrorCancelled)
- {
- _log.LogInformation("Update cancelled at the administrator prompt");
- Step = UpdateStep.Cancelled;
+ Process? setup;
+ try
+ {
+ setup = StartProcess(new ProcessStartInfo(installer, InstallerArguments) { UseShellExecute = true });
+ }
+ catch (Win32Exception ex) when (ex.NativeErrorCode == ErrorCancelled)
+ {
+ _log.LogInformation("Update cancelled at the administrator prompt");
+ Step = UpdateStep.Cancelled;
+ return;
+ }
+ catch (Exception ex) when (ex is Win32Exception or InvalidOperationException)
+ {
+ Fail("start", ex);
+ return;
+ }
+
+ _log.LogInformation("Started the installer for {Version}", LatestVersion);
+ Step = UpdateStep.Installing;
+ if (setup is null)
+ return;
+
+ using (setup)
+ await setup.WaitForExitAsync();
+ _log.LogInformation("Installer ended with exit code {Code}", setup.ExitCode);
+ Step = setup.ExitCode == 0 ? UpdateStep.Idle : UpdateStep.Cancelled;
return;
}
- catch (Exception ex) when (ex is Win32Exception or InvalidOperationException)
+
+ if (TargetPlatform.StartsWith("linux-", StringComparison.OrdinalIgnoreCase))
{
- Fail("start", ex);
- return;
- }
+ string? workspace = null;
+ string installer;
+ try
+ {
+ workspace = CreateSecureWorkspace();
+ var progress = new Progress<int>(percent => DownloadPercent = percent);
+ installer = await DownloadInstallerAsync(workspace, progress);
+ }
+ catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or IOException
+ or InvalidDataException or UnauthorizedAccessException)
+ {
+ DeleteSecureWorkspace(workspace);
+ Fail("download", ex);
+ return;
+ }
+
+ var stagingDir = Path.Combine(workspace, "payload");
+ string payloadDir;
+ try
+ {
+ Directory.CreateDirectory(stagingDir);
+ payloadDir = ExtractLinuxArchive(installer, stagingDir);
+ }
+ catch (Exception ex) when (ex is InvalidDataException or IOException or UnauthorizedAccessException)
+ {
+ DeleteSecureWorkspace(workspace);
+ Fail("extract", ex);
+ return;
+ }
+
+ var scriptPath = Path.Combine(payloadDir, "install.sh");
+ var targetInstallDir = LinuxInstallDirectoryOverride ?? GetLinuxInstallDirectory();
+ var newExe = Path.Combine(targetInstallDir, "Filee");
+ var currentPid = Environment.ProcessId;
+ var logDir = Path.Combine(UserDataStore.DefaultDirectory, "logs");
+ Directory.CreateDirectory(logDir);
+ var logFile = Path.Combine(logDir, $"filee-{DateTime.Now:yyyyMMdd}.log");
+ var markerFile = FailureMarkerPathOverride ?? Path.Combine(UserDataStore.DefaultDirectory, ".update-failed");
+
+ Process? helper;
+ try
+ {
+ var startInfo = new ProcessStartInfo("/bin/sh")
+ {
+ WorkingDirectory = payloadDir,
+ UseShellExecute = false,
+ };
+ startInfo.ArgumentList.Add("-c");
+ startInfo.ArgumentList.Add(
+ "for _ in $(seq 1 600); do if ! kill -0 \"$1\" 2>/dev/null; then break; fi; sleep 0.1; done; " +
+ "if kill -0 \"$1\" 2>/dev/null; then echo \"Update aborted: Filee (PID $1) did not exit within timeout\" >> \"$4\"; rm -rf \"$5\" 2>/dev/null; exit 1; fi; " +
+ "\"$2\" --upgrade >> \"$4\" 2>&1; " +
+ "status=$?; " +
+ "rm -rf \"$5\" 2>/dev/null; " +
+ "if [ $status -eq 0 ]; then " +
+ "if [ -x \"$3\" ]; then exec \"$3\" --background --whats-new; else echo \"Update succeeded but '$3' is not executable\" >> \"$4\"; exit 1; fi; " +
+ "else " +
+ "echo \"Update failed with status $status\" >> \"$4\"; " +
+ "echo \"$4\" > \"$6.tmp\" 2>/dev/null && mv -f \"$6.tmp\" \"$6\" 2>/dev/null || true; " +
+ "if [ -x \"$3\" ]; then exec \"$3\" --background; else echo \"Cannot restart Filee: '$3' is not executable after rollback\" >> \"$4\"; exit $status; fi; " +
+ "fi"
+ );
+ startInfo.ArgumentList.Add("_");
+ startInfo.ArgumentList.Add(currentPid.ToString());
+ startInfo.ArgumentList.Add(scriptPath);
+ startInfo.ArgumentList.Add(newExe);
+ startInfo.ArgumentList.Add(logFile);
+ startInfo.ArgumentList.Add(workspace);
+ startInfo.ArgumentList.Add(markerFile);
+
+ helper = StartProcess(startInfo);
+ }
+ catch (Exception ex) when (ex is Win32Exception or InvalidOperationException)
+ {
+ DeleteSecureWorkspace(workspace);
+ Fail("start", ex);
+ return;
+ }
- _log.LogInformation("Started the installer for {Version}", LatestVersion);
- Step = UpdateStep.Installing;
- if (setup is null)
+ _log.LogInformation("Started update helper for {Version}, exiting current process", LatestVersion);
+ Step = UpdateStep.Installing;
+ RequestApplicationShutdown?.Invoke();
return;
+ }
- // A successful update closes Filee before Setup exits, so getting here means Setup ended without updating:
- // the administrator prompt was declined (Setup asks for it itself), or the user cancelled.
- using (setup)
- await setup.WaitForExitAsync();
- _log.LogInformation("Installer ended with exit code {Code}", setup.ExitCode);
- Step = setup.ExitCode == 0 ? UpdateStep.Idle : UpdateStep.Cancelled;
+ throw new PlatformNotSupportedException("In-app update is only supported on Windows and Linux");
}
/// <summary>
diff --cc tests/Filee.App.Tests/UpdateServiceTests.cs
index edc832f3,667132fe..90b5324d
--- a/tests/Filee.App.Tests/UpdateServiceTests.cs
+++ b/tests/Filee.App.Tests/UpdateServiceTests.cs
@@@ -289,746 -410,31 +414,774 @@@ public class UpdateServiceTest
Assert.StartsWith(UpdateService.RepositoryUrl.TrimEnd('/'), UpdateService.LatestReleaseUrl);
}
+ [Theory]
+ [InlineData(Architecture.X64, "linux-x64")]
+ [InlineData(Architecture.Arm64, "linux-arm64")]
+ public void Architecture_maps_to_linux_rid(Architecture arch, string expectedRid) =>
+ Assert.Equal(expectedRid, UpdateService.GetLinuxRid(arch));
+
+ [Theory]
+ [InlineData(Architecture.Arm)]
+ [InlineData(Architecture.S390x)]
+ [InlineData(Architecture.Wasm)]
+ public void Architecture_unsupported_throws(Architecture arch) =>
+ Assert.Throws<PlatformNotSupportedException>(() => UpdateService.GetLinuxRid(arch));
+
+ [Fact]
+ public void IsLinuxInstalled_checks_marker_file()
+ {
+ var folder = TempFolder();
+ Assert.False(UpdateService.IsLinuxInstalled(folder));
+
+ var marker = Path.Combine(folder, ".filee-package");
+ File.WriteAllText(marker, "com.filee.app\n");
+ Assert.True(UpdateService.IsLinuxInstalled(folder));
+
+ File.WriteAllText(marker, "org.other.app");
+ Assert.False(UpdateService.IsLinuxInstalled(folder));
+ }
+
+ [Fact]
+ public void FindFiles_selects_linux_assets_for_specific_rid()
+ {
+ using var release = JsonDocument.Parse($$"""
+ {"tag_name": "v1.2.3", "assets": [
+ {"name": "Filee-1.2.3-SHA256SUMS.txt", "size": 100, "browser_download_url": "{{Base}}Filee-1.2.3-SHA256SUMS.txt"},
+ {"name": "Filee-1.2.3-win-Setup.exe", "size": 1200, "browser_download_url": "{{Base}}Filee-1.2.3-win-Setup.exe"},
+ {"name": "Filee-1.2.3-linux-x64.tar.gz", "size": 2000, "browser_download_url": "{{Base}}Filee-1.2.3-linux-x64.tar.gz"},
+ {"name": "Filee-1.2.3-linux-x64-SHA256SUMS.txt", "size": 90, "browser_download_url": "{{Base}}Filee-1.2.3-linux-x64-SHA256SUMS.txt"},
+ {"name": "Filee-1.2.3-linux-arm64.tar.gz", "size": 1900, "browser_download_url": "{{Base}}Filee-1.2.3-linux-arm64.tar.gz"},
+ {"name": "Filee-1.2.3-linux-arm64-SHA256SUMS.txt", "size": 92, "browser_download_url": "{{Base}}Filee-1.2.3-linux-arm64-SHA256SUMS.txt"}
+ ]}
+ """);
+
+ var (installerX64, sumsX64) = UpdateService.FindFiles(release.RootElement, "linux-x64");
+ Assert.Equal("Filee-1.2.3-linux-x64.tar.gz", installerX64?.Name);
+ Assert.Equal("Filee-1.2.3-linux-x64-SHA256SUMS.txt", sumsX64?.Name);
+
+ var (installerArm64, sumsArm64) = UpdateService.FindFiles(release.RootElement, "linux-arm64");
+ Assert.Equal("Filee-1.2.3-linux-arm64.tar.gz", installerArm64?.Name);
+ Assert.Equal("Filee-1.2.3-linux-arm64-SHA256SUMS.txt", sumsArm64?.Name);
+
+ var (installerWin, sumsWin) = UpdateService.FindFiles(release.RootElement, "win");
+ Assert.Equal("Filee-1.2.3-win-Setup.exe", installerWin?.Name);
+ Assert.Equal("Filee-1.2.3-SHA256SUMS.txt", sumsWin?.Name);
+ }
+
+ [Fact]
+ public async Task Checksum_file_for_different_artifact_is_rejected()
+ {
+ var installerData = RandomNumberGenerator.GetBytes(1000);
+ var hash = Sha256(installerData);
+ var folder = TempFolder();
+
+ var updates = new UpdateService(NullLogger<UpdateService>.Instance, new FakeLinuxRelease(
+ installerData, hash, sumsArtifact: "Filee-1.2.3-linux-arm64.tar.gz"));
+ updates.UseRelease(
+ new UpdateService.ReleaseFile("Filee-1.2.3-linux-x64.tar.gz", Base + "Filee-1.2.3-linux-x64.tar.gz", installerData.Length),
+ new UpdateService.ReleaseFile("Filee-1.2.3-linux-x64-SHA256SUMS.txt", Base + "Filee-1.2.3-linux-x64-SHA256SUMS.txt", 100));
+
+ await Assert.ThrowsAsync<InvalidDataException>(() =>
+ updates.DownloadInstallerAsync(folder, null, TestContext.Current.CancellationToken));
+ }
+
+ [Fact]
+ public void ExtractLinuxArchive_valid_payload_extracts_and_sets_permissions()
+ {
+ var folder = TempFolder();
+ var archiveFile = Path.Combine(folder, "package.tar.gz");
+ var destFolder = Path.Combine(folder, "extracted");
+
+ var tarBytes = CreateTarGz(writer =>
+ {
+ AddFileEntry(writer, "Filee-1.0.0-linux-x64/Filee", "#!/bin/sh\necho app\n");
+ AddFileEntry(writer, "Filee-1.0.0-linux-x64/install.sh", "#!/bin/sh\necho installer\n");
+ AddFileEntry(writer, "Filee-1.0.0-linux-x64/filee.png", "fake png data");
+ });
+ File.WriteAllBytes(archiveFile, tarBytes);
+
+ var payloadDir = UpdateService.ExtractLinuxArchive(archiveFile, destFolder);
+
+ Assert.Equal(Path.Combine(destFolder, "Filee-1.0.0-linux-x64"), payloadDir);
+ var installSh = Path.Combine(payloadDir, "install.sh");
+ var fileeExe = Path.Combine(payloadDir, "Filee");
+ Assert.True(File.Exists(installSh));
+ Assert.True(File.Exists(fileeExe));
+
+ if (OperatingSystem.IsLinux())
+ {
+ var installMode = File.GetUnixFileMode(installSh);
+ Assert.True((installMode & UnixFileMode.UserExecute) != 0, "install.sh must be executable");
+ var fileeMode = File.GetUnixFileMode(fileeExe);
+ Assert.True((fileeMode & UnixFileMode.UserExecute) != 0, "Filee must be executable");
+ }
+ }
+
+ [Fact]
+ public void ExtractLinuxArchive_rejects_path_traversal()
+ {
+ var folder = TempFolder();
+ var archiveFile = Path.Combine(folder, "traversal.tar.gz");
+ var destFolder = Path.Combine(folder, "extracted");
+
+ var tarBytes = CreateTarGz(writer =>
+ {
+ AddFileEntry(writer, "../evil.sh", "#!/bin/sh\n");
+ });
+ File.WriteAllBytes(archiveFile, tarBytes);
+
+ Assert.Throws<InvalidDataException>(() => UpdateService.ExtractLinuxArchive(archiveFile, destFolder));
+ }
+
+ [Fact]
+ public void ExtractLinuxArchive_rejects_absolute_path()
+ {
+ var folder = TempFolder();
+ var archiveFile = Path.Combine(folder, "absolute.tar.gz");
+ var destFolder = Path.Combine(folder, "extracted");
+
+ var tarBytes = CreateTarGz(writer =>
+ {
+ AddFileEntry(writer, "/tmp/evil.sh", "#!/bin/sh\n");
+ });
+ File.WriteAllBytes(archiveFile, tarBytes);
+
+ Assert.Throws<InvalidDataException>(() => UpdateService.ExtractLinuxArchive(archiveFile, destFolder));
+ }
+
+ [Fact]
+ public void ExtractLinuxArchive_rejects_escaping_symlink()
+ {
+ var folder = TempFolder();
+ var archiveFile = Path.Combine(folder, "symlink.tar.gz");
+ var destFolder = Path.Combine(folder, "extracted");
+
+ var tarBytes = CreateTarGz(writer =>
+ {
+ AddSymlinkEntry(writer, "Filee-1.0.0/escape_link", "/etc/passwd");
+ });
+ File.WriteAllBytes(archiveFile, tarBytes);
+
+ Assert.Throws<InvalidDataException>(() => UpdateService.ExtractLinuxArchive(archiveFile, destFolder));
+ }
+
+ [Fact]
+ public void ExtractLinuxArchive_rejects_missing_payload_files()
+ {
+ var folder = TempFolder();
+ var archiveFile = Path.Combine(folder, "missing.tar.gz");
+ var destFolder = Path.Combine(folder, "extracted");
+
+ var tarBytes = CreateTarGz(writer =>
+ {
+ AddFileEntry(writer, "Filee-1.0.0/filee.png", "png data");
+ });
+ File.WriteAllBytes(archiveFile, tarBytes);
+
+ Assert.Throws<InvalidDataException>(() => UpdateService.ExtractLinuxArchive(archiveFile, destFolder));
+ }
+
+ [AvaloniaFact]
+ public async Task UpdateAsync_on_linux_downloads_extracts_and_delegates_to_detached_helper()
+ {
+ var tarBytes = CreateTarGz(writer =>
+ {
+ AddFileEntry(writer, "Filee-9.9.9-linux-x64/Filee", "#!/bin/sh\nexit 0\n");
+ AddFileEntry(writer, "Filee-9.9.9-linux-x64/install.sh", "#!/bin/sh\nexit 0\n");
+ AddFileEntry(writer, "Filee-9.9.9-linux-x64/filee.png", "png data");
+ });
+ var hash = Sha256(tarBytes);
+ var network = new FakeLinuxRelease(tarBytes, hash, "Filee-9.9.9-linux-x64.tar.gz", "9.9.9");
+
+ var mockInstallDir = TempFolder();
+
+ var updates = new UpdateService(NullLogger<UpdateService>.Instance, network)
+ {
+ InstallsItself = true,
+ TargetPlatform = "linux-x64",
+ LinuxInstallDirectoryOverride = mockInstallDir,
+ };
+ updates.UseRelease(
+ new UpdateService.ReleaseFile("Filee-9.9.9-linux-x64.tar.gz", Base + "Filee-9.9.9-linux-x64.tar.gz", tarBytes.Length),
+ new UpdateService.ReleaseFile("Filee-9.9.9-linux-x64-SHA256SUMS.txt", Base + "Filee-9.9.9-linux-x64-SHA256SUMS.txt", 100));
+
+ var processes = new List<ProcessStartInfo>();
+ var shutdownRequested = false;
+ updates.RequestApplicationShutdown = () => shutdownRequested = true;
+ updates.StartProcess = psi =>
+ {
+ processes.Add(psi);
+ // No real process: `true` is missing on Windows without Git's tools on PATH.
+ return null;
+ };
+
+ await updates.UpdateAsync();
+
+ Assert.Equal(UpdateStep.Installing, updates.Step);
+ Assert.Single(processes);
+
+ var helperPsi = processes[0];
+ Assert.Equal("/bin/sh", helperPsi.FileName);
+ Assert.Equal("-c", helperPsi.ArgumentList[0]);
+ Assert.Contains("kill -0 \"$1\"", helperPsi.ArgumentList[1]);
+ Assert.Contains("\"$2\" --upgrade >> \"$4\" 2>&1", helperPsi.ArgumentList[1]);
+ Assert.Contains("exec \"$3\" --background --whats-new", helperPsi.ArgumentList[1]);
+ Assert.Contains("exec \"$3\" --background", helperPsi.ArgumentList[1]);
+ Assert.Contains("rm -rf \"$5\"", helperPsi.ArgumentList[1]);
+ Assert.Equal(Environment.ProcessId.ToString(), helperPsi.ArgumentList[3]);
+ Assert.EndsWith("install.sh", helperPsi.ArgumentList[4]);
+ Assert.Equal(Path.Combine(mockInstallDir, "Filee"), helperPsi.ArgumentList[5]);
+ Assert.EndsWith(".log", helperPsi.ArgumentList[6]);
+ Assert.EndsWith(".update-failed", helperPsi.ArgumentList[8]);
+
+ Assert.True(shutdownRequested, "Application shutdown must be requested before file swap");
+ }
+
+ [AvaloniaFact]
+ public async Task UpdateAsync_on_linux_handles_helper_start_failure()
+ {
+ var tarBytes = CreateTarGz(writer =>
+ {
+ AddFileEntry(writer, "Filee-9.9.9-linux-x64/Filee", "#!/bin/sh\nexit 0\n");
+ AddFileEntry(writer, "Filee-9.9.9-linux-x64/install.sh", "#!/bin/sh\nexit 0\n");
+ AddFileEntry(writer, "Filee-9.9.9-linux-x64/filee.png", "png data");
+ });
+ var hash = Sha256(tarBytes);
+ var network = new FakeLinuxRelease(tarBytes, hash, "Filee-9.9.9-linux-x64.tar.gz", "9.9.9");
+
+ var mockInstallDir = TempFolder();
+
+ var updates = new UpdateService(NullLogger<UpdateService>.Instance, network)
+ {
+ InstallsItself = true,
+ TargetPlatform = "linux-x64",
+ LinuxInstallDirectoryOverride = mockInstallDir,
+ };
+ updates.UseRelease(
+ new UpdateService.ReleaseFile("Filee-9.9.9-linux-x64.tar.gz", Base + "Filee-9.9.9-linux-x64.tar.gz", tarBytes.Length),
+ new UpdateService.ReleaseFile("Filee-9.9.9-linux-x64-SHA256SUMS.txt", Base + "Filee-9.9.9-linux-x64-SHA256SUMS.txt", 100));
+
+ var failedCount = 0;
+ updates.UpdateFailed += (_, _) => failedCount++;
+
+ var shutdownRequested = false;
+ updates.RequestApplicationShutdown = () => shutdownRequested = true;
+
+ updates.StartProcess = psi =>
+ throw new Win32Exception("Cannot spawn helper process");
+
+ await updates.UpdateAsync();
+
+ Assert.Equal(UpdateStep.Failed, updates.Step);
+ Assert.Equal(1, failedCount);
+ Assert.NotNull(updates.LastError);
+ Assert.Contains("Cannot spawn helper process", updates.LastError.Message);
+ Assert.False(shutdownRequested, "Application shutdown must not be requested when helper fails to start");
+ }
+
+ [Fact]
+ public void ExtractLinuxArchive_rejects_symlink_component_traversal()
+ {
+ var outsideFolder = TempFolder();
+ var sentinelFile = Path.Combine(outsideFolder, "sentinel.txt");
+ File.WriteAllText(sentinelFile, "SENTINEL_UNTOUCHED");
+
+ var stagingFolder = TempFolder();
+ var archiveFile = Path.Combine(stagingFolder, "evil-traversal.tar.gz");
+ var destFolder = Path.Combine(stagingFolder, "dest");
+
+ var tarBytes = CreateTarGz(writer =>
+ {
+ // Adversarial entry 1: directory symlink pointing outside to outsideFolder
+ AddSymlinkEntry(writer, "payload/escape", outsideFolder);
+ // Adversarial entry 2: file inside escape pointing to sentinel.txt
+ AddFileEntry(writer, "payload/escape/sentinel.txt", "MALICIOUS_OVERWRITE");
+ });
+ File.WriteAllBytes(archiveFile, tarBytes);
+
+ Assert.Throws<InvalidDataException>(() => UpdateService.ExtractLinuxArchive(archiveFile, destFolder));
+ Assert.Equal("SENTINEL_UNTOUCHED", File.ReadAllText(sentinelFile));
+ }
+
+ [Fact]
+ public void ExtractLinuxArchive_rejects_link_order_attack()
+ {
+ var stagingFolder = TempFolder();
+ var archiveFile = Path.Combine(stagingFolder, "evil-link-order.tar.gz");
+ var destFolder = Path.Combine(stagingFolder, "dest");
+
+ var tarBytes = CreateTarGz(writer =>
+ {
+ // Entry 1: regular directory
+ var dirEntry = new PaxTarEntry(TarEntryType.Directory, "payload/sub");
+ writer.WriteEntry(dirEntry);
+ // Entry 2: attempt to replace directory with a symlink
+ AddSymlinkEntry(writer, "payload/sub", "other");
+ });
+ File.WriteAllBytes(archiveFile, tarBytes);
+
+ Assert.Throws<InvalidDataException>(() => UpdateService.ExtractLinuxArchive(archiveFile, destFolder));
+ }
+
+ [Fact]
+ public void CreateSecureWorkspace_creates_private_unshared_directory()
+ {
+ var workspace = UpdateService.CreateSecureWorkspace();
+ try
+ {
+ Assert.True(Directory.Exists(workspace));
+ var dirInfo = new DirectoryInfo(workspace);
+ Assert.Null(dirInfo.LinkTarget);
+ Assert.False(dirInfo.Attributes.HasFlag(FileAttributes.ReparsePoint));
+
+ if (OperatingSystem.IsLinux())
+ {
+ var mode = File.GetUnixFileMode(workspace);
+ Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute, mode);
+ }
+ }
+ finally
+ {
+ UpdateService.DeleteSecureWorkspace(workspace);
+ Assert.False(Directory.Exists(workspace));
+ }
+ }
+
+ [Fact]
+ public void DeleteSecureWorkspace_refuses_to_follow_symlink()
+ {
+ var realDir = TempFolder();
+ var targetFile = Path.Combine(realDir, "important.txt");
+ File.WriteAllText(targetFile, "CRITICAL_DATA");
+
+ var linkContainer = TempFolder();
+ var symlinkPath = Path.Combine(linkContainer, "link-to-real");
+ try
+ {
+ File.CreateSymbolicLink(symlinkPath, realDir);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Assert.Skip("This machine doesn't let the test make a symbolic link.");
+ }
+
+ UpdateService.DeleteSecureWorkspace(symlinkPath);
+
+ Assert.True(Directory.Exists(realDir), "Real directory must not be deleted when DeleteSecureWorkspace is called on a symlink");
+ Assert.True(File.Exists(targetFile), "File inside real directory must survive");
+ }
+
+ [Fact]
+ public async Task Concurrent_secure_workspaces_are_isolated()
+ {
+ var isolatedDir = TempFolder();
+ try
+ {
+ var tasks = Enumerable.Range(0, 5).Select(_ => Task.Run(() => UpdateService.CreateSecureWorkspace(isolatedDir))).ToArray();
+ var workspaces = await Task.WhenAll(tasks);
+
+ Assert.Equal(5, workspaces.Distinct().Count());
+ Assert.All(workspaces, w =>
+ {
+ Assert.True(Directory.Exists(w));
+ Assert.StartsWith(isolatedDir, w);
+ });
+ }
+ finally
+ {
+ try
+ {
+ if (Directory.Exists(isolatedDir))
+ Directory.Delete(isolatedDir, recursive: true);
+ }
+ catch
+ {
+ // Best effort test cleanup
+ }
+ }
+ }
+
+ [Fact]
+ public void Tar_extraction_masks_mode_to_rwx_bits()
+ {
+ var tarBytes = CreateTarGz(writer =>
+ {
+ var setuidMode = UnixFileMode.SetUser | UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute
+ | UnixFileMode.GroupRead | UnixFileMode.GroupExecute | UnixFileMode.OtherRead | UnixFileMode.OtherExecute;
+ var setgidMode = UnixFileMode.SetGroup | UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute
+ | UnixFileMode.GroupRead | UnixFileMode.GroupExecute | UnixFileMode.OtherRead | UnixFileMode.OtherExecute;
+ AddFileEntry(writer, "Filee-9.9.9-linux-x64/Filee", "#!/bin/sh\nexit 0\n", setuidMode);
+ AddFileEntry(writer, "Filee-9.9.9-linux-x64/install.sh", "#!/bin/sh\nexit 0\n", setgidMode);
+ });
+ var archiveFile = Path.Combine(TempFolder(), "payload.tar.gz");
+ File.WriteAllBytes(archiveFile, tarBytes);
+
+ var destFolder = TempFolder();
+ var payloadDir = UpdateService.ExtractLinuxArchive(archiveFile, destFolder);
+
+ if (OperatingSystem.IsLinux())
+ {
+ var fileeMode = File.GetUnixFileMode(Path.Combine(payloadDir, "Filee"));
+ var installMode = File.GetUnixFileMode(Path.Combine(payloadDir, "install.sh"));
+
+ Assert.False(fileeMode.HasFlag(UnixFileMode.SetUser), "setuid bit must be stripped");
+ Assert.False(fileeMode.HasFlag(UnixFileMode.SetGroup), "setgid bit must be stripped");
+ Assert.False(fileeMode.HasFlag(UnixFileMode.StickyBit), "sticky bit must be stripped");
+
+ Assert.False(installMode.HasFlag(UnixFileMode.SetUser), "setuid bit must be stripped");
+ Assert.False(installMode.HasFlag(UnixFileMode.SetGroup), "setgid bit must be stripped");
+ Assert.False(installMode.HasFlag(UnixFileMode.StickyBit), "sticky bit must be stripped");
+ }
+ }
+
+ [Fact]
+ public void CheckPendingFailure_returns_false_when_marker_absent()
+ {
+ var dir = TempFolder();
+ var updates = new UpdateService(NullLogger<UpdateService>.Instance)
+ {
+ FailureMarkerPathOverride = Path.Combine(dir, ".update-failed"),
+ };
+
+ var result = updates.CheckPendingFailure(dir);
+ Assert.False(result);
+ Assert.Equal(UpdateStep.Idle, updates.Step);
+ Assert.Null(updates.LastFailureLogPath);
+ }
+
+ [Fact]
+ public void CheckPendingFailure_consumes_marker_and_records_failure()
+ {
+ var dir = TempFolder();
+ var marker = Path.Combine(dir, ".update-failed");
+ var logPath = Path.Combine(dir, "logs", "filee-test.log");
+ Directory.CreateDirectory(Path.GetDirectoryName(logPath)!);
+ File.WriteAllText(logPath, "some error log");
+ File.WriteAllText(marker, logPath + "\n");
+
+ var updates = new UpdateService(NullLogger<UpdateService>.Instance)
+ {
+ FailureMarkerPathOverride = marker,
+ };
+
+ var result = updates.CheckPendingFailure(dir);
+ Assert.True(result);
+ Assert.Equal(UpdateStep.Failed, updates.Step);
+ Assert.Equal(logPath, updates.LastFailureLogPath);
+ Assert.False(File.Exists(marker), "Marker file must be consumed (deleted)");
+ }
+
+ [Fact]
+ public void CheckPendingFailure_handles_malformed_marker_safely()
+ {
+ var dir = TempFolder();
+ var marker = Path.Combine(dir, ".update-failed");
+ File.WriteAllText(marker, "not-a-rooted-path\0evil");
+
+ var updates = new UpdateService(NullLogger<UpdateService>.Instance)
+ {
+ FailureMarkerPathOverride = marker,
+ };
+
+ var result = updates.CheckPendingFailure(dir);
+ Assert.True(result);
+ Assert.Equal(UpdateStep.Failed, updates.Step);
+ Assert.Null(updates.LastFailureLogPath);
+ Assert.False(File.Exists(marker), "Marker file must still be consumed");
+ }
+
+ [Fact]
+ public void DeleteStaleWorkspaces_preserves_active_pid_and_deletes_stale_dead_pid()
+ {
+ var root = TempFolder();
+ var token1 = "0123456789abcdef0123456789abcdef";
+ var token2 = "abcdef0123456789abcdef0123456789";
+ var token3 = "11223344556677889900aabbccddeeff";
+ var activeDir = Path.Combine(root, $".update-{Environment.ProcessId}-{token1}");
+ var deadPid = 999999;
+ while (UpdateService.IsProcessAlive(deadPid))
+ deadPid++;
+
+ var deadStaleDir = Path.Combine(root, $".update-{deadPid}-{token2}");
+ var deadFreshDir = Path.Combine(root, $".update-{deadPid}-{token3}");
+
+ Directory.CreateDirectory(activeDir);
+ Directory.CreateDirectory(deadStaleDir);
+ Directory.CreateDirectory(deadFreshDir);
+
+ Directory.SetLastWriteTimeUtc(deadStaleDir, DateTime.UtcNow.AddDays(-2));
+
+ UpdateService.DeleteStaleWorkspaces(root, TimeSpan.FromDays(1));
+
+ Assert.True(Directory.Exists(activeDir), "Active PID workspace must not be deleted even if stale");
+ Assert.False(Directory.Exists(deadStaleDir), "Stale dead PID workspace must be deleted");
+ Assert.True(Directory.Exists(deadFreshDir), "Fresh dead PID workspace must be kept");
+ }
+
+ [Fact]
+ public void DeleteStaleWorkspaces_ignores_foreign_and_malformed_directories()
+ {
+ var root = TempFolder();
+ var token32 = "0123456789abcdef0123456789abcdef";
+
+ // Foreign directories and malformed names
+ var foreign1 = Path.Combine(root, ".update-something");
+ var foreign2 = Path.Combine(root, ".update-cache");
+ var malformedZeroPid = Path.Combine(root, $".update-0-{token32}");
+ var malformedNegativePid = Path.Combine(root, $".update--123-{token32}");
+ var malformedNonDecimalPid = Path.Combine(root, $".update-abc-{token32}");
+ var malformedShortToken = Path.Combine(root, ".update-12345-0123456789abcdef");
+ var malformedLongToken = Path.Combine(root, $".update-12345-{token32}extra");
+ var malformedNonHexToken = Path.Combine(root, ".update-12345-0123456789abcdef0123456789abcdeg");
+ var malformedExtraSegment = Path.Combine(root, $".update-12345-{token32}-extra");
+
+ var allFolders = new[]
+ {
+ foreign1, foreign2, malformedZeroPid, malformedNegativePid,
+ malformedNonDecimalPid, malformedShortToken, malformedLongToken,
+ malformedNonHexToken, malformedExtraSegment
+ };
+
+ foreach (var dir in allFolders)
+ {
+ Directory.CreateDirectory(dir);
+ File.WriteAllText(Path.Combine(dir, "content.txt"), "preserve me");
+ Directory.SetLastWriteTimeUtc(dir, DateTime.UtcNow.AddDays(-2));
+ }
+
+ UpdateService.DeleteStaleWorkspaces(root, TimeSpan.FromDays(1));
+
+ foreach (var dir in allFolders)
+ {
+ Assert.True(Directory.Exists(dir), $"Directory {Path.GetFileName(dir)} must remain untouched");
+ Assert.True(File.Exists(Path.Combine(dir, "content.txt")), $"File inside {Path.GetFileName(dir)} must survive");
+ }
+ }
+
+ [Theory]
+ [InlineData(".update-123-0123456789abcdef0123456789abcdef", true, 123)]
+ [InlineData(".update-1-0123456789ABCDEF0123456789ABCDEF", true, 1)]
+ [InlineData(".update-999999-abcdef0123456789abcdef0123456789", true, 999999)]
+ [InlineData(".update-something", false, 0)]
+ [InlineData(".update-cache", false, 0)]
+ [InlineData(".update-", false, 0)]
+ [InlineData(".update-0-0123456789abcdef0123456789abcdef", false, 0)]
+ [InlineData(".update--123-0123456789abcdef0123456789abcdef", false, 0)]
+ [InlineData(".update-+123-0123456789abcdef0123456789abcdef", false, 0)]
+ [InlineData(".update-abc-0123456789abcdef0123456789abcdef", false, 0)]
+ [InlineData(".update-123-short", false, 0)]
+ [InlineData(".update-123-0123456789abcdef0123456789abcdefextra", false, 0)]
+ [InlineData(".update-123-0123456789abcdef0123456789abcdeg", false, 0)]
+ [InlineData(".update-123-0123456789abcdef-0123456789abcdef", false, 0)]
+ [InlineData("other-123-0123456789abcdef0123456789abcdef", false, 0)]
+ public void TryParseWorkspaceName_validates_pattern(string name, bool expectedResult, int expectedPid)
+ {
+ var result = UpdateService.TryParseWorkspaceName(name, out var pid);
+ Assert.Equal(expectedResult, result);
+ Assert.Equal(expectedPid, pid);
+ }
+
+ [Fact]
+ public void Helper_script_restarts_filee_on_failure_and_writes_marker()
+ {
+ if (!OperatingSystem.IsLinux())
+ return;
+
+ var tempDir = TempFolder();
+ var workspace = Path.Combine(tempDir, "workspace");
+ Directory.CreateDirectory(workspace);
+
+ var installLog = Path.Combine(tempDir, "install.log");
+ var markerFile = Path.Combine(tempDir, ".update-failed");
+
+ var mockInstallSh = Path.Combine(tempDir, "install.sh");
+ File.WriteAllText(mockInstallSh, "#!/bin/sh\necho 'Rolling back...' >&2\nexit 2\n");
+ File.SetUnixFileMode(mockInstallSh, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
+
+ var argsOut = Path.Combine(tempDir, "filee-args.txt");
+ var mockFilee = Path.Combine(tempDir, "Filee");
+ File.WriteAllText(mockFilee, $"#!/bin/sh\necho \"$@\" > '{argsOut}'\nexit 0\n");
+ File.SetUnixFileMode(mockFilee, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
+
+ var deadPid = 999999;
+ while (UpdateService.IsProcessAlive(deadPid))
+ deadPid++;
+
+ var script =
+ "for _ in $(seq 1 600); do if ! kill -0 \"$1\" 2>/dev/null; then break; fi; sleep 0.1; done; " +
+ "if kill -0 \"$1\" 2>/dev/null; then echo \"Update aborted: Filee (PID $1) did not exit within timeout\" >> \"$4\"; rm -rf \"$5\" 2>/dev/null; exit 1; fi; " +
+ "\"$2\" --upgrade >> \"$4\" 2>&1; " +
+ "status=$?; " +
+ "rm -rf \"$5\" 2>/dev/null; " +
+ "if [ $status -eq 0 ]; then " +
+ "if [ -x \"$3\" ]; then exec \"$3\" --background --whats-new; else echo \"Update succeeded but '$3' is not executable\" >> \"$4\"; exit 1; fi; " +
+ "else " +
+ "echo \"Update failed with status $status\" >> \"$4\"; " +
+ "echo \"$4\" > \"$6.tmp\" 2>/dev/null && mv -f \"$6.tmp\" \"$6\" 2>/dev/null || true; " +
+ "if [ -x \"$3\" ]; then exec \"$3\" --background; else echo \"Cannot restart Filee: '$3' is not executable after rollback\" >> \"$4\"; exit $status; fi; " +
+ "fi";
+
+ using var proc = Process.Start(new ProcessStartInfo("/bin/sh")
+ {
+ ArgumentList = { "-c", script, "_", deadPid.ToString(), mockInstallSh, mockFilee, installLog, workspace, markerFile },
+ UseShellExecute = false,
+ });
+
+ Assert.NotNull(proc);
+ Assert.True(proc.WaitForExit(5000));
+ Assert.Equal(0, proc.ExitCode);
+
+ Assert.False(Directory.Exists(workspace), "Workspace directory must be cleaned up on failure");
+ Assert.True(File.Exists(markerFile), "Failure marker file must be created");
+ Assert.Equal(installLog, File.ReadAllText(markerFile).Trim());
+
+ Assert.True(File.Exists(argsOut), "Restored Filee executable must have been launched");
+ var args = File.ReadAllText(argsOut).Trim();
+ Assert.Equal("--background", args);
+ Assert.DoesNotContain("--whats-new", args);
+ }
+
+ [Fact]
+ public void Helper_script_cleans_up_workspace_on_timeout()
+ {
+ if (!OperatingSystem.IsLinux())
+ return;
+
+ var tempDir = TempFolder();
+ var workspace = Path.Combine(tempDir, "workspace");
+ Directory.CreateDirectory(workspace);
+
+ var installLog = Path.Combine(tempDir, "install.log");
+ var markerFile = Path.Combine(tempDir, ".update-failed");
+ var mockInstallSh = Path.Combine(tempDir, "install.sh");
+ File.WriteAllText(mockInstallSh, "#!/bin/sh\nexit 0\n");
+ var mockFilee = Path.Combine(tempDir, "Filee");
+ File.WriteAllText(mockFilee, "#!/bin/sh\nexit 0\n");
+
+ var timeoutScript =
+ "for _ in $(seq 1 2); do if ! kill -0 \"$1\" 2>/dev/null; then break; fi; sleep 0.01; done; " +
+ "if kill -0 \"$1\" 2>/dev/null; then echo \"Update aborted: Filee (PID $1) did not exit within timeout\" >> \"$4\"; rm -rf \"$5\" 2>/dev/null; exit 1; fi; " +
+ "\"$2\" --upgrade >> \"$4\" 2>&1; " +
+ "status=$?; " +
+ "rm -rf \"$5\" 2>/dev/null; " +
+ "if [ $status -eq 0 ]; then " +
+ "if [ -x \"$3\" ]; then exec \"$3\" --background --whats-new; else echo \"Update succeeded but '$3' is not executable\" >> \"$4\"; exit 1; fi; " +
+ "else " +
+ "echo \"Update failed with status $status\" >> \"$4\"; " +
+ "echo \"$4\" > \"$6.tmp\" 2>/dev/null && mv -f \"$6.tmp\" \"$6\" 2>/dev/null || true; " +
+ "if [ -x \"$3\" ]; then exec \"$3\" --background; else echo \"Cannot restart Filee: '$3' is not executable after rollback\" >> \"$4\"; exit $status; fi; " +
+ "fi";
+
+ using var proc = Process.Start(new ProcessStartInfo("/bin/sh")
+ {
+ ArgumentList = { "-c", timeoutScript, "_", Environment.ProcessId.ToString(), mockInstallSh, mockFilee, installLog, workspace, markerFile },
+ UseShellExecute = false,
+ });
+
+ Assert.NotNull(proc);
+ Assert.True(proc.WaitForExit(5000));
+ Assert.Equal(1, proc.ExitCode);
+
+ Assert.False(Directory.Exists(workspace), "Workspace must be cleaned up on timeout");
+ Assert.Contains("Update aborted: Filee", File.ReadAllText(installLog));
+ }
+
+ private static byte[] CreateTarGz(Action<TarWriter> populate)
+ {
+ using var mem = new MemoryStream();
+ using (var gzip = new GZipStream(mem, CompressionMode.Compress, leaveOpen: true))
+ using (var writer = new TarWriter(gzip, TarEntryFormat.Pax, leaveOpen: true))
+ {
+ populate(writer);
+ }
+ return mem.ToArray();
+ }
+
+ private static void AddFileEntry(TarWriter writer, string name, string content, UnixFileMode mode = UnixFileMode.UserRead | UnixFileMode.UserWrite)
+ {
+ var bytes = Encoding.UTF8.GetBytes(content);
+ var entry = new PaxTarEntry(TarEntryType.RegularFile, name)
+ {
+ DataStream = new MemoryStream(bytes),
+ Mode = mode,
+ };
+ writer.WriteEntry(entry);
+ }
+
+ private static void AddSymlinkEntry(TarWriter writer, string name, string target)
+ {
+ var entry = new PaxTarEntry(TarEntryType.SymbolicLink, name)
+ {
+ LinkName = target,
+ };
+ writer.WriteEntry(entry);
+ }
+
+ private sealed class FakeLinuxRelease(byte[] archive, string hash, string sumsArtifact = "Filee-9.9.9-linux-x64.tar.gz", string version = "9.9.9") : HttpMessageHandler
+ {
+ protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+ {
+ var url = request.RequestUri!.ToString();
+ if (url.EndsWith("/releases/latest", StringComparison.Ordinal))
+ {
+ var json = $$"""
+ {"tag_name":"v{{version}}","assets":[
+ {"name":"Filee-{{version}}-linux-x64.tar.gz","browser_download_url":"{{Base}}Filee-{{version}}-linux-x64.tar.gz","size":{{archive.Length}}},
+ {"name":"Filee-{{version}}-linux-x64-SHA256SUMS.txt","browser_download_url":"{{Base}}Filee-{{version}}-linux-x64-SHA256SUMS.txt","size":100}]}
+ """;
+ return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
+ {
+ Content = new StringContent(json, Encoding.UTF8, "application/json"),
+ });
+ }
+ if (url.Contains("/releases?per_page=", StringComparison.Ordinal) || url.EndsWith("/releases", StringComparison.Ordinal))
+ {
+ return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
+ {
+ Content = new StringContent("[]", Encoding.UTF8, "application/json"),
+ });
+ }
+ if (url.EndsWith("SHA256SUMS.txt", StringComparison.Ordinal))
+ {
+ return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
+ {
+ Content = new StringContent($"{hash} {sumsArtifact}\n", Encoding.ASCII),
+ });
+ }
+ if (url.EndsWith(".tar.gz", StringComparison.Ordinal))
+ {
+ Assert.Contains("application/octet-stream", request.Headers.Accept.ToString());
+ return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(archive) });
+ }
+ return Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound));
+ }
+ }
++
+ [AvaloniaFact]
+ public void UpdateProgressWindow_tracks_download_percentage_and_status()
+ {
+ TestServices.EnsureInitialized();
+ var updates = new UpdateService(NullLogger<UpdateService>.Instance, new FakeNetwork("no network"));
+ updates.LatestVersion = "2.1.0";
+ updates.Step = UpdateStep.Downloading;
+ updates.DownloadPercent = 45;
+
+ var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
+ var window = new Views.UpdateProgressWindow(updates, loc);
+
+ Assert.Equal(45, window.ProgressBar.Value);
+ Assert.Equal("45%", window.PercentText.Text);
+ Assert.DoesNotContain("45%", window.StatusText.Text);
+ Assert.StartsWith(loc["update.downloading"].Split('…')[0], window.StatusText.Text);
+
+ updates.DownloadPercent = 90;
+ Assert.Equal(90, window.ProgressBar.Value);
+ Assert.Equal("90%", window.PercentText.Text);
+
+ updates.Step = UpdateStep.Installing;
+ Assert.True(window.ProgressBar.IsIndeterminate);
+
+ updates.Step = UpdateStep.Cancelled;
+ Assert.False(window.ProgressBar.IsVisible);
+ }
}