feat: make folder decrypter aware of archived versions

Signed-off-by: Tommy van der Vorst <tommy@pixelspark.nl>

Author: pixelspark

Localizable.xcstrings

@@ -9522,6 +9522,52 @@
         }
       }
     },
+    "Current version" : {
+      "localizations" : {
+        "de" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Aktuelle Version"
+          }
+        },
+        "es" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Versión actual"
+          }
+        },
+        "it" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Versione corrente"
+          }
+        },
+        "ja" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "現在のバージョン"
+          }
+        },
+        "nl" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Huidige versie"
+          }
+        },
+        "uk" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Поточна версія"
+          }
+        },
+        "zh-Hans" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "当前版本"
+          }
+        }
+      }
+    },
     "Currently no files are being downloaded from other devices." : {
       "localizations" : {
         "de" : {

Sushitrain/DecrypterView.swift

@@ -29,7 +29,7 @@ import SwiftUI
 		@State private var folderPassword: String = ""
 		@State private var searchText: String = ""
 		@State private var destURL: URL? = nil
-		@State private var selectedDecryptedPaths: Set<String> = []
+		@State private var selectedURLs: Set<String> = []
 		@State private var showSuccessMessage = false
 		@State private var keepFolderStructure = true
 
@@ -63,7 +63,7 @@ import SwiftUI
 							.disabled(folderPassword.isEmpty || folderID.isEmpty || sourceURL == nil)
 						}
 
-						Section("\(selectedDecryptedPaths.count) files selected") {
+						Section("\(selectedURLs.count) files selected") {
 							LabeledContent("Folder") {
 								HStack {
 									Text(destURL?.lastPathComponent ?? "")
@@ -78,12 +78,12 @@ import SwiftUI
 								Text("Recreate folder structure")
 							}
 
-							Button("Decrypt \(selectedDecryptedPaths.count) files") {
+							Button("Decrypt \(selectedURLs.count) files") {
 								Task {
 									await self.decryptSelection()
 								}
 							}.disabled(destURL == nil)
-						}.disabled(folderPassword.isEmpty || folderID.isEmpty || sourceURL == nil || selectedDecryptedPaths.isEmpty)
+						}.disabled(folderPassword.isEmpty || folderID.isEmpty || sourceURL == nil || selectedURLs.isEmpty)
 					}
 					.formStyle(.grouped)
 					.disabled(loading)
@@ -106,7 +106,7 @@ import SwiftUI
 							DecrypterItemsView(
 								folderID: folderID, folderPassword: folderPassword,
 								entries: searchText.isEmpty ? allEntries : foundEntries,
-								selectedDecryptedPaths: $selectedDecryptedPaths
+								selectedURLs: $selectedURLs
 							)
 							.id(searchText)
 						}
@@ -176,11 +176,13 @@ import SwiftUI
 					if trimmedPath.starts(with: ".stfolder") {
 						continue
 					}
-					let decryptedPath = folderKey.decryptedFilePath(trimmedPath, error: &error)
+
+					let encryptedFilePath = EncryptedFilePath(trimmedPath)
+					let decryptedPath = folderKey.decryptedFilePath(encryptedFilePath.pathWithoutVersion, error: &error)
 					if let e = error {
 						throw e
 					}
-					entries.append(EncryptedFileEntry(decryptedPath: decryptedPath, url: c))
+					entries.append(EncryptedFileEntry(decryptedPath: decryptedPath, url: c, version: encryptedFilePath.version))
 				}
 			}
 		}
@@ -193,7 +195,7 @@ import SwiftUI
 			let folderID = self.folderID
 			let folderPassword = self.folderPassword
 			let destURL = self.destURL
-			let selectedDecryptedPaths = self.selectedDecryptedPaths
+			let selectedURLs = self.selectedURLs
 			let sourceURL = self.sourceURL
 			let keepFolderStructure = self.keepFolderStructure
 			let entries = self.allEntries
@@ -204,16 +206,19 @@ import SwiftUI
 					try withExtendedLifetime(try BookmarkManager.Accessor(url: destURL!)) {
 						let folderKey = SushitrainNewFolderKey(folderID, folderPassword)
 						for entry in entries {
-							if !selectedDecryptedPaths.contains(entry.decryptedPath) {
+							if !selectedURLs.contains(entry.url.absoluteString) {
 								continue
 							}
 
 							let rootPath = sourceURL!.path(percentEncoded: false)
 							let filePath = entry.url.path(percentEncoded: false)
 							let trimmedPath = String(filePath.trimmingPrefix(rootPath))
-							Log.info("Decrypt \(trimmedPath) \(sourceURL!) \(destURL!)")
+							let encryptedPath = EncryptedFilePath(trimmedPath)
+							Log.info("Decrypt \(trimmedPath) \(sourceURL!) \(destURL!) \(entry.version ?? "current version")")
 							try folderKey?.decryptFile(
-								sourceURL?.path(percentEncoded: false), encryptedPath: trimmedPath,
+								sourceURL?.path(percentEncoded: false),
+								encryptedPathWithVersion: encryptedPath.actualPath,
+								encryptedPathWithoutVersion: encryptedPath.pathWithoutVersion,
 								destRoot: destURL?.path(percentEncoded: false),
 								keepFolderStructure: keepFolderStructure
 							)
@@ -291,20 +296,50 @@ import SwiftUI
 
 		var decryptedPath: String
 		var url: URL
+		var version: String?
 	}
 
 	private struct DecrypterItemsView: View {
 		let folderID: String
 		let folderPassword: String
 		let entries: [EncryptedFileEntry]
 		@State private var decryptedPaths: [String] = []
+		@State private var entriesByDecryptedPath: [String: [EncryptedFileEntry]] = [:]
 
-		@Binding var selectedDecryptedPaths: Set<String>
+		@Binding var selectedURLs: Set<String>
 
 		var body: some View {
-			List(selection: $selectedDecryptedPaths) {
+			List(selection: $selectedURLs) {
 				PathsOutlineGroup(paths: decryptedPaths, disableIntermediateSelection: true) { decryptedPath, isIntermediate in
-					Text(decryptedPath.lastPathComponent)
+					if let entries = self.entriesByDecryptedPath[decryptedPath] {
+						if entries.count > 1 || (entries.count == 1 && entries[0].version != nil) {
+							DisclosureGroup {
+								ForEach(entries) { entry in
+									if let version = entry.version {
+										if let date = dateFromVersionString(version) {
+											Label(
+												date.formatted(date: .abbreviated, time: .complete),
+												systemImage: "clock.arrow.trianglehead.2.counterclockwise.rotate.90"
+											).tag(entry.url)
+										}
+										else {
+											Label(version, systemImage: "clock.arrow.trianglehead.2.counterclockwise.rotate.90").tag(entry.url)
+										}
+									}
+									else {
+										Label("Current version", systemImage: "clock.fill").tag(entry.url)
+									}
+								}
+							} label: {
+								let currentEntry = entries.first(where: { $0.version == nil })
+								Label(decryptedPath.lastPathComponent, systemImage: "doc").tag(currentEntry?.url).disabled(currentEntry == nil)
+							}
+						}
+						else {
+							let entry = entries[0]
+							Label(decryptedPath.lastPathComponent, systemImage: "doc").tag(entry.url)
+						}
+					}
 				}
 			}
 			.task {
@@ -314,7 +349,32 @@ import SwiftUI
 
 		private func update() async {
 			self.decryptedPaths = self.entries.map { $0.decryptedPath }
+			self.entriesByDecryptedPath = Dictionary(grouping: self.entries, by: { $0.decryptedPath })
 		}
 	}
 
 #endif
+
+private struct EncryptedFilePath {
+	let version: String?
+	let pathWithoutVersion: String
+	let actualPath: String
+
+	// A versioned encrypted path will look like:
+	// .stversions/A.syncthing-enc/BC/DEFXYZ~20260102-030405
+	init(_ originalPath: String) {
+		self.actualPath = originalPath
+		if originalPath.starts(with: ".stversions/") {
+			// Trim off '.stversions/', decrypt the path, and store the version
+			if let tildeIndex = originalPath.lastIndex(of: "~"), tildeIndex != originalPath.endIndex {
+				self.version = String(originalPath[originalPath.index(after: tildeIndex)...])
+				self.pathWithoutVersion = String(
+					String(originalPath[...originalPath.index(before: tildeIndex)]).trimmingPrefix(".stversions/"))
+				return
+			}
+		}
+
+		self.pathWithoutVersion = originalPath
+		self.version = nil
+	}
+}

Sushitrain/Utils.swift

@@ -1251,3 +1251,13 @@ extension Binding where Value == Bool {
 			get: { underlying.wrappedValue != nil }, set: { underlying.wrappedValue = $0 ? underlying.wrappedValue : nil })
 	}
 }
+
+/// Translate version tags appended by Syncthing in a .stversions folder to a date
+/// These look like '20260102-030405' and are in *local time* at the point of creation
+/// So we can only assume here that that matches our local time.
+func dateFromVersionString(_ version: String) -> Date? {
+	let dateFormatter = DateFormatter()
+	dateFormatter.locale = Locale(identifier: "en_US_POSIX")
+	dateFormatter.dateFormat = "yyyyMMdd-HHmmss"
+	return dateFormatter.date(from: version)
+}

SushitrainCore/src/encryption.go

@@ -125,8 +125,8 @@ func (fk *FolderKey) DecryptedFilePath(path string) (string, error) {
 	return decryptName(path, fk.key)
 }
 
-func (fk *FolderKey) DecryptFile(encryptedRoot string, encryptedPath string, destRoot string, keepFolderStructure bool) error {
-	destPath, err := fk.DecryptedFilePath(encryptedPath)
+func (fk *FolderKey) DecryptFile(encryptedRoot string, encryptedPathWithVersion string, encryptedPathWithoutVersion string, destRoot string, keepFolderStructure bool) error {
+	destPath, err := fk.DecryptedFilePath(encryptedPathWithoutVersion)
 	if err != nil {
 		return err
 	}
@@ -144,7 +144,7 @@ func (fk *FolderKey) DecryptFile(encryptedRoot string, encryptedPath string, des
 
 	// Load encrypted file info
 	srcFs := fs.NewFilesystem(fs.FilesystemTypeBasic, encryptedRoot)
-	encFd, err := srcFs.Open(encryptedPath)
+	encFd, err := srcFs.Open(encryptedPathWithVersion)
 	if err != nil {
 		return err
 	}
@@ -159,13 +159,13 @@ func (fk *FolderKey) DecryptFile(encryptedRoot string, encryptedPath string, des
 
 	encryptedBlocks, encryptedFileInfoBytes, err := loadBlocks(encFd)
 	if err != nil {
-		return fmt.Errorf("%s: loading metadata trailer: %w", encryptedPath, err)
+		return fmt.Errorf("%s: loading metadata trailer: %w", encryptedPathWithVersion, err)
 	}
 
 	// Construct a fake FileInfo object that satisfies protocol.DecryptFileInfo just enough to trick it into decrypting
 	// the Encrypted field.
 	encryptedFileInfo := protocol.FileInfo{
-		Name:      encryptedPath,
+		Name:      encryptedPathWithoutVersion,
 		Encrypted: encryptedFileInfoBytes,
 	}