diff --git a/007SaveTool/App.xaml b/007SaveTool/App.xaml
new file mode 100644
index 0000000..82422a5
--- /dev/null
+++ b/007SaveTool/App.xaml
@@ -0,0 +1,198 @@
+
+
+
+ #1A1A2E
+ #16213E
+ #0F3460
+ #D4AF37
+ #F0C840
+ #E8E8E8
+ #A0A8B8
+ #6A7280
+ #22C55E
+ #EF4444
+ #F59E0B
+ #3B82F6
+ #1E3A5F
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/007SaveTool/App.xaml.cs b/007SaveTool/App.xaml.cs
new file mode 100644
index 0000000..516162a
--- /dev/null
+++ b/007SaveTool/App.xaml.cs
@@ -0,0 +1,5 @@
+using System.Windows;
+
+namespace EonaCat.FirstLight.SaveTransfer;
+
+public partial class App : Application { }
diff --git a/007SaveTool/EonaCat.FirstLight.SaveTransfer.csproj b/007SaveTool/EonaCat.FirstLight.SaveTransfer.csproj
new file mode 100644
index 0000000..1411c48
--- /dev/null
+++ b/007SaveTool/EonaCat.FirstLight.SaveTransfer.csproj
@@ -0,0 +1,17 @@
+
+
+
+ WinExe
+ net8.0-windows
+ enable
+ enable
+ true
+ EonaCat.FirstLight.SaveTransfer
+ EonaCat.FirstLight.SaveTransfer
+ icon.ico
+ AnyCPU
+ false
+ true
+
+
+
diff --git a/007SaveTool/MainWindow.xaml b/007SaveTool/MainWindow.xaml
new file mode 100644
index 0000000..2e99c91
--- /dev/null
+++ b/007SaveTool/MainWindow.xaml
@@ -0,0 +1,292 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Find your SteamID64 at
+
+ steamid.io
+
+ — it looks like 76561197960272671
+
+
+
+
+
+
+ When left blank the tool will auto-detect from index.save
+ and bruteforce the data.save key.
+
+
+
+
+
+
+
+ Auto-confirm SteamID mismatches between
+ index.save and
+ data.save
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Leave blank to auto-detect from index.save.
+ Output files will be saved next to the originals with a .decrypted extension.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/007SaveTool/MainWindow.xaml.cs b/007SaveTool/MainWindow.xaml.cs
new file mode 100644
index 0000000..1ae943a
--- /dev/null
+++ b/007SaveTool/MainWindow.xaml.cs
@@ -0,0 +1,428 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Navigation;
+
+namespace EonaCat.FirstLight.SaveTransfer;
+
+public partial class MainWindow : Window
+{
+ private readonly StringBuilder _logBuffer = new();
+
+ public MainWindow()
+ {
+ InitializeComponent();
+ MainTabs.SelectionChanged += MainTabs_SelectionChanged;
+ }
+
+ private void MainTabs_SelectionChanged(object sender, SelectionChangedEventArgs e)
+ {
+ if (MainTabs.SelectedItem is not TabItem tab)
+ {
+ return;
+ }
+
+ PanelResign.Visibility = Visibility.Collapsed;
+ PanelDecrypt.Visibility = Visibility.Collapsed;
+ PanelLog.Visibility = Visibility.Collapsed;
+
+ if (tab == TabResign)
+ {
+ PanelResign.Visibility = Visibility.Visible;
+ }
+
+ if (tab == TabDecrypt)
+ {
+ PanelDecrypt.Visibility = Visibility.Visible;
+ }
+
+ if (tab == TabLog)
+ {
+ PanelLog.Visibility = Visibility.Visible;
+ }
+ }
+
+ private void BrowseResignFolder_Click(object sender, RoutedEventArgs e)
+ {
+ string? path = BrowseForFolder();
+ if (path is null)
+ {
+ return;
+ }
+
+ TxtResignFolder.Text = path;
+ TxtResignFolder.Foreground = (Brush)FindResource("TextPrimaryBrush");
+ }
+
+ private void BrowseDecryptFolder_Click(object sender, RoutedEventArgs e)
+ {
+ string? path = BrowseForFolder();
+ if (path is null)
+ {
+ return;
+ }
+
+ TxtDecryptFolder.Text = path;
+ TxtDecryptFolder.Foreground = (Brush)FindResource("TextPrimaryBrush");
+ }
+
+ private static string? BrowseForFolder()
+ {
+ var dlg = new Microsoft.Win32.OpenFolderDialog
+ {
+ Title = "Select your save folder (e.g. …\\userdata\\\\3768760\\remote)",
+ };
+ return dlg.ShowDialog() == true ? dlg.FolderName : null;
+ }
+
+ private void NumericOnly_PreviewInput(object sender, TextCompositionEventArgs e)
+ {
+ foreach (char c in e.Text)
+ {
+ if (!char.IsDigit(c)) { e.Handled = true; return; }
+ }
+ }
+
+ private async void BtnResign_Click(object sender, RoutedEventArgs e)
+ {
+ string folder = TxtResignFolder.Text.Trim();
+ if (string.IsNullOrEmpty(folder) || folder.StartsWith("Click"))
+ { ShowBanner(ResignResultBanner, ResignResultText, "Please select a save folder first.", BannerKind.Error); return; }
+
+ string targetText = TxtTargetSID.Text.Trim();
+ if (!ulong.TryParse(targetText, out ulong targetSid))
+ { ShowBanner(ResignResultBanner, ResignResultText, "Please enter a valid Target SteamID64.", BannerKind.Error); return; }
+
+ ulong? userSourceSid = null;
+ string sourceText = TxtSourceSID.Text.Trim();
+ if (!string.IsNullOrEmpty(sourceText))
+ {
+ if (!ulong.TryParse(sourceText, out ulong s))
+ { ShowBanner(ResignResultBanner, ResignResultText, "Source SteamID64 is invalid — leave blank to auto-detect.", BannerKind.Error); return; }
+ userSourceSid = s;
+ }
+
+ bool autoConfirm = ChkAutoConfirm.IsChecked == true;
+
+ SetBusy(true, BtnResign, ResignProgress);
+ HideBanner(ResignResultBanner);
+
+ var log = new List();
+ int resignedDirs = 0;
+ string summary;
+
+ try
+ {
+ (resignedDirs, summary) = await Task.Run(() =>
+ RunResign(folder, targetSid, userSourceSid, autoConfirm, log));
+ }
+ finally
+ {
+ SetBusy(false, BtnResign, ResignProgress);
+ }
+
+ // Flush to log tab
+ AppendLog(log);
+ UpdateStatusBar($"Resigned {resignedDirs} save container(s).");
+
+ bool success = resignedDirs > 0;
+ ShowBanner(ResignResultBanner, ResignResultText, summary,
+ success ? BannerKind.Success : BannerKind.Warning);
+ }
+
+ private static (int resigned, string summary) RunResign(
+ string rootDir, ulong targetSid, ulong? userSourceSid,
+ bool autoConfirm, List log)
+ {
+ var containers = SaveCore.FindSaveContainers(rootDir);
+ if (containers.Count == 0)
+ {
+ log.Add("[INFO] No save containers found (no index.save / data.save).");
+ return (0, "No save containers found in the selected folder.");
+ }
+
+ int resignedDirs = 0;
+
+ foreach (var container in containers)
+ {
+ log.Add($"\nFound save container: {container.Directory}");
+
+ string indexPath = System.IO.Path.Combine(container.Directory, "index.save");
+ string dataPath = System.IO.Path.Combine(container.Directory, "data.save");
+
+ if (container.HasIndex && container.HasData)
+ {
+ ulong? indexSid = SaveCore.DetectSourceSteamIdFromIndex(indexPath);
+ log.Add(" [AUTO] Bruteforcing data.save encryption key…");
+ var sw = System.Diagnostics.Stopwatch.StartNew();
+ ulong? dataSid = SaveCore.BruteforceDataSaveKey(dataPath);
+ sw.Stop();
+
+ if (dataSid.HasValue)
+ {
+ log.Add($" [AUTO] data.save key cracked in {sw.Elapsed.TotalSeconds:F3}s: {dataSid}");
+ }
+ else
+ {
+ log.Add(" [ERROR] Bruteforce failed. Skipping. Use manual Source SteamID.");
+ continue;
+ }
+
+ if (!indexSid.HasValue)
+ {
+ log.Add(" [ERROR] index.save auto-detect failed. Skipping.");
+ continue;
+ }
+
+ if (indexSid == dataSid)
+ {
+ log.Add($" [OK] Both files bound to SteamID64: {indexSid}");
+ ulong src = userSourceSid ?? indexSid.Value;
+ SaveCore.ResignIndexFile(indexPath, src, targetSid, log);
+ SaveCore.ResignDataFile(dataPath, src, targetSid, log);
+ }
+ else
+ {
+ log.Add($" [WARNING] STEAMID MISMATCH!");
+ log.Add($" index.save → {indexSid}");
+ log.Add($" data.save → {dataSid}");
+
+ if (userSourceSid.HasValue)
+ {
+ log.Add($" Using manual override: {userSourceSid}");
+ SaveCore.ResignIndexFile(indexPath, userSourceSid.Value, targetSid, log);
+ SaveCore.ResignDataFile(dataPath, userSourceSid.Value, targetSid, log);
+ }
+ else if (autoConfirm)
+ {
+ log.Add(" Proceeding with split re-signing (auto-confirm).");
+ SaveCore.ResignIndexFile(indexPath, indexSid.Value, targetSid, log);
+ SaveCore.ResignDataFile(dataPath, dataSid.Value, targetSid, log);
+ }
+ else
+ {
+ // In GUI mode without auto-confirm, default to split signing
+ log.Add(" Proceeding with dynamic split re-signing.");
+ SaveCore.ResignIndexFile(indexPath, indexSid.Value, targetSid, log);
+ SaveCore.ResignDataFile(dataPath, dataSid.Value, targetSid, log);
+ }
+ }
+ resignedDirs++;
+ }
+ else if (container.HasIndex)
+ {
+ ulong? indexSid = SaveCore.DetectSourceSteamIdFromIndex(indexPath);
+ if (!indexSid.HasValue)
+ { log.Add(" [ERROR] index.save auto-detect failed. Skipping."); continue; }
+
+ ulong src = userSourceSid ?? indexSid.Value;
+ SaveCore.ResignIndexFile(indexPath, src, targetSid, log);
+ log.Add(" [INFO] No data.save present.");
+ resignedDirs++;
+ }
+ else if (container.HasData)
+ {
+ log.Add(" [AUTO] Bruteforcing data.save…");
+ ulong? dataSid = SaveCore.BruteforceDataSaveKey(dataPath);
+ if (!dataSid.HasValue)
+ { log.Add(" [ERROR] Bruteforce failed. Skipping."); continue; }
+
+ ulong src = userSourceSid ?? dataSid.Value;
+ SaveCore.ResignDataFile(dataPath, src, targetSid, log);
+ log.Add(" [INFO] No index.save present.");
+ resignedDirs++;
+ }
+ }
+
+ string summary = resignedDirs > 0
+ ? $"✓ Resigned {resignedDirs} save container(s) successfully. Backups created."
+ : "No containers were resigned. Check the Log tab for details.";
+ return (resignedDirs, summary);
+ }
+
+ private async void BtnDecrypt_Click(object sender, RoutedEventArgs e)
+ {
+ string folder = TxtDecryptFolder.Text.Trim();
+ if (string.IsNullOrEmpty(folder) || folder.StartsWith("Click"))
+ { ShowBanner(DecryptResultBanner, DecryptResultText, "Please select a save folder first.", BannerKind.Error); return; }
+
+ ulong? manualSid = null;
+ string sidText = TxtDecryptSID.Text.Trim();
+ if (!string.IsNullOrEmpty(sidText))
+ {
+ if (!ulong.TryParse(sidText, out ulong s))
+ { ShowBanner(DecryptResultBanner, DecryptResultText, "SteamID64 is invalid.", BannerKind.Error); return; }
+ manualSid = s;
+ }
+
+ SetBusy(true, BtnDecrypt, DecryptProgress);
+ HideBanner(DecryptResultBanner);
+
+ var log = new List();
+ int processed;
+ string summary;
+
+ try
+ {
+ (processed, summary) = await Task.Run(() =>
+ RunDecrypt(folder, manualSid, log));
+ }
+ finally
+ {
+ SetBusy(false, BtnDecrypt, DecryptProgress);
+ }
+
+ AppendLog(log);
+ UpdateStatusBar($"Decrypted {processed} container(s).");
+
+ ShowBanner(DecryptResultBanner, DecryptResultText, summary,
+ processed > 0 ? BannerKind.Success : BannerKind.Warning);
+ }
+
+ private static (int processed, string summary) RunDecrypt(
+ string rootDir, ulong? manualSid, List log)
+ {
+ var containers = SaveCore.FindSaveContainers(rootDir);
+ if (containers.Count == 0)
+ {
+ log.Add("[INFO] No save containers found.");
+ return (0, "No save containers found in the selected folder.");
+ }
+
+ int processedCount = 0;
+
+ foreach (var container in containers)
+ {
+ log.Add($"\nSave container: {container.Directory}");
+ string indexPath = System.IO.Path.Combine(container.Directory, "index.save");
+ string dataPath = System.IO.Path.Combine(container.Directory, "data.save");
+
+ ulong? decSid = manualSid;
+
+ if (!decSid.HasValue)
+ {
+ if (container.HasIndex)
+ {
+ decSid = SaveCore.DetectSourceSteamIdFromIndex(indexPath);
+ if (decSid.HasValue)
+ {
+ log.Add($" [AUTO] Detected SteamID64: {decSid}");
+ }
+ else
+ { log.Add(" [ERROR] Auto-detect failed. Skipping."); continue; }
+ }
+ else
+ { log.Add(" [ERROR] No index.save for auto-detection. Skipping."); continue; }
+ }
+
+ if (container.HasIndex)
+ {
+ SaveCore.DecryptIndexFile(indexPath, decSid.Value, log);
+ }
+
+ if (container.HasData)
+ {
+ SaveCore.DecryptDataFile(dataPath, decSid.Value, log);
+ }
+
+ processedCount++;
+ }
+
+ string summary = processedCount > 0
+ ? $"✓ Decrypted {processedCount} container(s). .decrypted files written."
+ : "Nothing was decrypted. Check the Log tab for details.";
+ return (processedCount, summary);
+ }
+
+ private void AppendLog(IEnumerable lines)
+ {
+ Dispatcher.Invoke(() =>
+ {
+ foreach (string line in lines)
+ {
+ _logBuffer.AppendLine(line);
+ // Colour-code lines
+ var run = new Run(line + "\n");
+ if (line.Contains("[SUCCESS]") || line.Contains("[OK]") || line.StartsWith(" ✓"))
+ {
+ run.Foreground = (Brush)FindResource("SuccessBrush");
+ }
+ else if (line.Contains("[ERROR]"))
+ {
+ run.Foreground = (Brush)FindResource("ErrorBrush");
+ }
+ else if (line.Contains("[WARNING]") || line.Contains("[WARN]"))
+ {
+ run.Foreground = (Brush)FindResource("WarningBrush");
+ }
+ else if (line.Contains("[AUTO]") || line.Contains("[INFO]"))
+ {
+ run.Foreground = (Brush)FindResource("InfoBrush");
+ }
+ else
+ {
+ run.Foreground = (Brush)FindResource("TextSecondaryBrush");
+ }
+
+ TxtLog.Inlines.Add(run);
+ }
+ LogScroll.ScrollToBottom();
+ });
+ }
+
+ private void ClearLog_Click(object sender, RoutedEventArgs e)
+ {
+ TxtLog.Inlines.Clear();
+ _logBuffer.Clear();
+ }
+
+ private void Hyperlink_RequestNavigate(object sender, RequestNavigateEventArgs e)
+ {
+ Process.Start(new ProcessStartInfo(e.Uri.AbsoluteUri) { UseShellExecute = true });
+ e.Handled = true;
+ }
+
+ private void SetBusy(bool busy, Button btn, System.Windows.Controls.ProgressBar progress)
+ {
+ btn.IsEnabled = !busy;
+ progress.Visibility = busy ? Visibility.Visible : Visibility.Collapsed;
+ TxtStatus.Text = busy ? "Working…" : "Ready";
+ }
+
+ private void UpdateStatusBar(string msg) =>
+ TxtStatusBar.Text = msg;
+
+ private enum BannerKind { Success, Warning, Error, Info }
+
+ private void ShowBanner(Border banner, TextBlock text, string message, BannerKind kind)
+ {
+ banner.Visibility = Visibility.Visible;
+ text.Text = message;
+ banner.Background = kind switch
+ {
+ BannerKind.Success => new SolidColorBrush(Color.FromArgb(40, 34, 197, 94)),
+ BannerKind.Warning => new SolidColorBrush(Color.FromArgb(40, 245, 158, 11)),
+ BannerKind.Error => new SolidColorBrush(Color.FromArgb(40, 239, 68, 68)),
+ _ => new SolidColorBrush(Color.FromArgb(40, 59, 130, 246)),
+ };
+ banner.BorderBrush = kind switch
+ {
+ BannerKind.Success => (Brush)FindResource("SuccessBrush"),
+ BannerKind.Warning => (Brush)FindResource("WarningBrush"),
+ BannerKind.Error => (Brush)FindResource("ErrorBrush"),
+ _ => (Brush)FindResource("InfoBrush"),
+ };
+ banner.BorderThickness = new Thickness(1);
+ text.Foreground = banner.BorderBrush;
+ }
+
+ private static void HideBanner(Border banner) =>
+ banner.Visibility = Visibility.Collapsed;
+}
diff --git a/007SaveTool/SaveCore.cs b/007SaveTool/SaveCore.cs
new file mode 100644
index 0000000..ffeaf9f
--- /dev/null
+++ b/007SaveTool/SaveCore.cs
@@ -0,0 +1,399 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace EonaCat.FirstLight.SaveTransfer;
+
+///
+/// All encryption uses XOR with the little-endian SteamID64 (8-byte repeating key).
+///
+public static class SaveCore
+{
+
+ private static byte[] GetSteamIdKeyBytes(ulong steamId64)
+ {
+ // struct.pack(">= 8; }
+ return key;
+ }
+
+ /// XOR every byte with the 8-byte repeating SteamID key.
+ public static byte[] XorWithSteamId(ReadOnlySpan data, ulong steamId64)
+ {
+ byte[] key = GetSteamIdKeyBytes(steamId64);
+ byte[] result = new byte[data.Length];
+ for (int i = 0; i < data.Length; i++)
+ {
+ result[i] = (byte)(data[i] ^ key[i % 8]);
+ }
+
+ return result;
+ }
+
+ ///
+ /// Read bytes 24..27 (little-endian uint32) from index.save, convert to SteamID64.
+ ///
+ public static ulong? DetectSourceSteamIdFromIndex(string indexPath)
+ {
+ // Use the Backup copy if available
+ string backupPath = Path.Combine(Path.GetDirectoryName(indexPath)!, "Backup",
+ Path.GetFileName(indexPath));
+ string targetPath = File.Exists(backupPath) ? backupPath : indexPath;
+
+ if (!File.Exists(targetPath))
+ {
+ return null;
+ }
+
+ try
+ {
+ byte[] data = File.ReadAllBytes(targetPath);
+ if (data.Length < 28)
+ {
+ return null;
+ }
+
+ uint accountId = BitConverter.ToUInt32(data, 24); // little-endian uint32
+ return 76561197960265728UL + accountId;
+ }
+ catch { return null; }
+ }
+
+ ///
+ /// Recover the SteamID64 used to encrypt data.save by brute-forcing bytes 2 and 3
+ /// of the key while exploiting known zlib header magic (CMF=0x78).
+ ///
+ public static ulong? BruteforceDataSaveKey(string filePath, IProgress? progress = null)
+ {
+ if (!File.Exists(filePath))
+ {
+ return null;
+ }
+
+ string backupPath = Path.Combine(Path.GetDirectoryName(filePath)!, "Backup",
+ Path.GetFileName(filePath));
+ string targetPath = File.Exists(backupPath) ? backupPath : filePath;
+
+ byte[] ciphertext;
+ try { ciphertext = File.ReadAllBytes(targetPath); }
+ catch { return null; }
+
+ if (ciphertext.Length < 32)
+ {
+ return null;
+ }
+
+ // b0 comes from knowing first plaintext byte is 0x78 (zlib CMF)
+ byte b0 = (byte)(ciphertext[0] ^ 0x78);
+
+ // b1 candidates from valid zlib FLG values that make (cmf*256+flg) % 31 == 0
+ // where cmf = 0x78: 0x78*256 + flg must be divisible by 31
+ // valid_flgs = [0x01, 0x5E, 0x9C, 0xDA]
+ byte[] validFlgs = [0x01, 0x5E, 0x9C, 0xDA];
+ byte[] b1Candidates = new byte[validFlgs.Length];
+ for (int i = 0; i < validFlgs.Length; i++)
+ {
+ b1Candidates[i] = (byte)(ciphertext[1] ^ validFlgs[i]);
+ }
+
+ byte[] headerChunk = ciphertext[..16];
+
+ foreach (byte b1 in b1Candidates)
+ {
+ for (int b2 = 0; b2 < 256; b2++)
+ {
+ for (int b3 = 0; b3 < 256; b3++)
+ {
+ // Key bytes 0..7 — tail bytes 4..7 fixed as [0x01,0x00,0x10,0x01]
+ // (matches the game's SteamID encoding pattern)
+ byte[] key = [b0, b1, (byte)b2, (byte)b3, 0x01, 0x00, 0x10, 0x01];
+
+ // Decrypt first 2 bytes only to check zlib header
+ byte cmf = (byte)(headerChunk[0] ^ key[0]);
+ byte flg = (byte)(headerChunk[1] ^ key[1]);
+
+ if (cmf != 0x78)
+ {
+ continue;
+ }
+
+ if ((cmf * 256 + flg) % 31 != 0)
+ {
+ continue;
+ }
+
+ // Verify with first 128 bytes
+ try
+ {
+ byte[] verifyChunk = new byte[Math.Min(128, ciphertext.Length)];
+ for (int i = 0; i < verifyChunk.Length; i++)
+ {
+ verifyChunk[i] = (byte)(ciphertext[i] ^ key[i % 8]);
+ }
+
+ using var ms = new MemoryStream(verifyChunk);
+ using var zs = new ZLibStream(ms, CompressionMode.Decompress);
+ byte[] dummy = new byte[256];
+ zs.Read(dummy, 0, dummy.Length);
+ }
+ catch { continue; }
+
+ // Full decompression to confirm
+ try
+ {
+ byte[] fullDecrypted = new byte[ciphertext.Length];
+ for (int i = 0; i < ciphertext.Length; i++)
+ {
+ fullDecrypted[i] = (byte)(ciphertext[i] ^ key[i % 8]);
+ }
+
+ using var ms2 = new MemoryStream(fullDecrypted);
+ using var zs2 = new ZLibStream(ms2, CompressionMode.Decompress);
+ using var output = new MemoryStream();
+ zs2.CopyTo(output);
+ // success — reconstruct ulong SteamID64 from key bytes
+ ulong steamId = BitConverter.ToUInt64(key, 0);
+ return steamId;
+ }
+ catch { continue; }
+ }
+ }
+ }
+ return null;
+ }
+
+ ///
+ /// Resign index.save: XOR out the old key and XOR in the new key in one pass.
+ /// Creates a Backup/ copy before modifying.
+ ///
+ public static void ResignIndexFile(string filePath, ulong fromSid, ulong toSid,
+ List log)
+ {
+ log.Add($" Resigning index.save: {filePath}");
+
+ byte[] originalCiphertext = File.ReadAllBytes(filePath);
+ byte[] fromKey = GetSteamIdKeyBytes(fromSid);
+ byte[] toKey = GetSteamIdKeyBytes(toSid);
+
+ byte[] newCiphertext = new byte[originalCiphertext.Length];
+ for (int i = 0; i < originalCiphertext.Length; i++)
+ {
+ newCiphertext[i] = (byte)(originalCiphertext[i] ^ fromKey[i % 8] ^ toKey[i % 8]);
+ }
+
+ EnsureBackup(filePath, log);
+
+ File.WriteAllBytes(filePath, newCiphertext);
+ log.Add(" [SUCCESS] index.save resigned successfully.");
+ }
+
+ ///
+ /// Resign data.save: decrypt (XOR + zlib decompress), recompress (zlib level 4), re-encrypt.
+ /// Returns false if decompression fails.
+ ///
+ public static bool ResignDataFile(string filePath, ulong fromSid, ulong toSid,
+ List log)
+ {
+ log.Add($" Resigning data.save: {filePath}");
+
+ byte[] originalCiphertext = File.ReadAllBytes(filePath);
+ byte[] fromKey = GetSteamIdKeyBytes(fromSid);
+ byte[] toKey = GetSteamIdKeyBytes(toSid);
+
+ // Step 1: XOR-decrypt with source key
+ byte[] decryptedXor = new byte[originalCiphertext.Length];
+ for (int i = 0; i < originalCiphertext.Length; i++)
+ {
+ decryptedXor[i] = (byte)(originalCiphertext[i] ^ fromKey[i % 8]);
+ }
+
+ // Step 2: Zlib decompress
+ byte[] decompressedPayload;
+ try
+ {
+ using var ms = new MemoryStream(decryptedXor);
+ using var zs = new ZLibStream(ms, CompressionMode.Decompress);
+ using var output = new MemoryStream();
+ zs.CopyTo(output);
+ decompressedPayload = output.ToArray();
+ log.Add($" [OK] Decompressed payload: {decompressedPayload.Length:N0} bytes.");
+ }
+ catch (Exception ex)
+ {
+ log.Add($" [ERROR] Decompression failed — source SteamID may be wrong. {ex.Message}");
+ return false;
+ }
+
+ // Step 3: Recompress at level 4
+ byte[] compressedPayload;
+ using (var msOut = new MemoryStream())
+ {
+ using var zOut = new ZLibStream(msOut, CompressionLevel.Optimal);
+ zOut.Write(decompressedPayload, 0, decompressedPayload.Length);
+ zOut.Flush();
+ compressedPayload = msOut.ToArray();
+ }
+
+ // Step 4: XOR-encrypt with target key
+ byte[] newCiphertext = new byte[compressedPayload.Length];
+ for (int i = 0; i < compressedPayload.Length; i++)
+ {
+ newCiphertext[i] = (byte)(compressedPayload[i] ^ toKey[i % 8]);
+ }
+
+ EnsureBackup(filePath, log);
+
+ File.WriteAllBytes(filePath, newCiphertext);
+ log.Add($" [SUCCESS] data.save resigned. ({originalCiphertext.Length:N0} → {newCiphertext.Length:N0} bytes)");
+ return true;
+ }
+
+ ///
+ /// Decrypt index.save and write a .decrypted file alongside it.
+ ///
+ public static void DecryptIndexFile(string filePath, ulong steamSid, List log)
+ {
+ log.Add($" Processing index.save: {filePath}");
+
+ byte[] data = File.ReadAllBytes(filePath);
+ if (data.Length < 8) { log.Add(" [ERROR] File too short."); return; }
+
+ byte[] decrypted = XorWithSteamId(data, steamSid);
+
+ // Check for header structure marker
+ int idx = IndexOf(decrypted, "SSaveGameHeader"u8);
+ if (idx >= 0)
+ {
+ log.Add(" [OK] Header verified: found 'SSaveGameHeader'");
+ }
+ else
+ {
+ log.Add(" [WARN] 'SSaveGameHeader' not found — SteamID may be incorrect.");
+ }
+
+ string outPath = filePath + ".decrypted";
+ File.WriteAllBytes(outPath, decrypted);
+ log.Add($" [SUCCESS] → {Path.GetFileName(outPath)}");
+ }
+
+ ///
+ /// Decrypt data.save (XOR + zlib decompress) and write a .decrypted file.
+ ///
+ public static bool DecryptDataFile(string filePath, ulong steamSid, List log)
+ {
+ log.Add($" Processing data.save: {filePath}");
+
+ byte[] ciphertext = File.ReadAllBytes(filePath);
+ byte[] decryptedXor = XorWithSteamId(ciphertext, steamSid);
+
+ try
+ {
+ byte[] decompressed;
+ using (var ms = new MemoryStream(decryptedXor))
+ using (var zs = new ZLibStream(ms, CompressionMode.Decompress))
+ using (var output = new MemoryStream())
+ {
+ zs.CopyTo(output);
+ decompressed = output.ToArray();
+ }
+
+ log.Add($" [OK] Decompressed: {decompressed.Length:N0} bytes.");
+
+ // Extract save class type name (bytes 8..8+head_len), head_len at offset 4
+ if (decompressed.Length >= 32)
+ {
+ uint rawLen = BitConverter.ToUInt32(decompressed, 4);
+ int headLen = (int)(rawLen & 0x3FFFFFFF);
+ if (headLen < 100 && headLen > 0 && 8 + headLen <= decompressed.Length)
+ {
+ string typeName = Encoding.Latin1.GetString(decompressed, 8, headLen);
+ log.Add($" Save class type: '{typeName}'");
+ }
+ }
+
+ string outPath = filePath + ".decrypted";
+ File.WriteAllBytes(outPath, decompressed);
+ log.Add($" [SUCCESS] → {Path.GetFileName(outPath)}");
+ return true;
+ }
+ catch (Exception ex)
+ {
+ log.Add($" [ERROR] Decompression failed — SteamID {steamSid} may be incorrect. {ex.Message}");
+ return false;
+ }
+ }
+
+ private static void EnsureBackup(string filePath, List log)
+ {
+ string backupDir = Path.Combine(Path.GetDirectoryName(filePath)!, "Backup");
+ string backupPath = Path.Combine(backupDir, Path.GetFileName(filePath));
+ if (!Directory.Exists(backupDir))
+ {
+ Directory.CreateDirectory(backupDir);
+ }
+
+ if (!File.Exists(backupPath))
+ {
+ File.Copy(filePath, backupPath);
+ log.Add($" [OK] Backup → {backupPath}");
+ }
+ }
+
+ private static int IndexOf(ReadOnlySpan haystack, ReadOnlySpan needle)
+ {
+ for (int i = 0; i <= haystack.Length - needle.Length; i++)
+ {
+ if (haystack.Slice(i, needle.Length).SequenceEqual(needle))
+ {
+ return i;
+ }
+ }
+
+ return -1;
+ }
+
+ public record SaveContainer(string Directory, bool HasIndex, bool HasData);
+
+ ///
+ /// Walk a root directory recursively looking for folders that contain
+ /// index.save and/or data.save (ignoring Backup sub-dirs).
+ ///
+ public static List FindSaveContainers(string rootDir)
+ {
+ var results = new List();
+ ScanDir(rootDir, results);
+ return results;
+ }
+
+ private static void ScanDir(string dir, List results)
+ {
+ try
+ {
+ string dirName = Path.GetFileName(dir);
+ if (string.Equals(dirName, "Backup", StringComparison.OrdinalIgnoreCase))
+ {
+ return;
+ }
+
+ string[] files = Directory.GetFiles(dir);
+ bool hasIndex = Array.Exists(files, f => Path.GetFileName(f).Equals("index.save", StringComparison.OrdinalIgnoreCase));
+ bool hasData = Array.Exists(files, f => Path.GetFileName(f).Equals("data.save", StringComparison.OrdinalIgnoreCase));
+
+ if (hasIndex || hasData)
+ {
+ results.Add(new SaveContainer(dir, hasIndex, hasData));
+ }
+
+ foreach (string sub in Directory.GetDirectories(dir))
+ {
+ ScanDir(sub, results);
+ }
+ }
+ catch { /* access denied, skip */ }
+ }
+}
diff --git a/007SaveTool/icon.ico b/007SaveTool/icon.ico
new file mode 100644
index 0000000..406f265
Binary files /dev/null and b/007SaveTool/icon.ico differ
diff --git a/EonaCat.FirstLight.SaveTransfer.sln b/EonaCat.FirstLight.SaveTransfer.sln
new file mode 100644
index 0000000..ac63c63
--- /dev/null
+++ b/EonaCat.FirstLight.SaveTransfer.sln
@@ -0,0 +1,21 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 18
+VisualStudioVersion = 18.5.11801.241 oobstable
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EonaCat.FirstLight.SaveTransfer", "007SaveTool\EonaCat.FirstLight.SaveTransfer.csproj", "{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|AnyCPU = Debug|AnyCPU
+ Release|AnyCPU = Release|AnyCPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|AnyCPU.ActiveCfg = Debug|AnyCPU
+ {A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|AnyCPU.Build.0 = Debug|AnyCPU
+ {A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|AnyCPU.ActiveCfg = Release|AnyCPU
+ {A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|AnyCPU.Build.0 = Release|AnyCPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal